rado 1.0.10 → 1.0.12

package/README.md

@@ -5,200 +5,330 @@
 
 Fully typed, lightweight TypeScript query builder.
 
-- Definition via TypeScript types
-- Composable queries
-- First class JSON columns
-- No code generation step
-- No dependencies
+## Features
+
+- Fully typed queries using TypeScript
+- Composable and reusable query structures
+- First-class support for JSON columns
+- No code generation step required
+- Zero dependencies
+- Universal query support for multiple database engines
+
+## Installation
 
 <pre>npm install <a href="https://www.npmjs.com/package/rado">rado</a></pre>
 
-## Queries
+## Quick Start
 
-#### Where
+```typescript
+import {table} from 'rado'
+import {text, integer} from 'rado/postgres'
+import {connect} from 'rado/driver/pg'
+import {Pool} from 'pg'
 
-Conditions can be created by accessing the fields of the table:
+// Define your schema
+const User = table({
+  id: integer().primaryKey(),
+  name: text().notNull(),
+  email: text().unique()
+})
 
-```ts
-import {eq} from 'rado'
-eq(User.id, 1) // Compare with a value
-eq(User.id, Post.userId) // Compare to fields on other tables
+// Connect to the database
+const db = connect(new Pool({
+  host: 'localhost',
+  database: 'my_database'
+}))
+
+// Perform a query
+const users = await db.select().from(User)
+console.log(users)
 ```
 
-Rows can be selected by passing the condition in the where method:
+## Supported Databases
 
-```ts
-import {eq, or, gt, lt} from 'rado'
-db.select().from(User).where(eq(User.id, 1))
-// Conditions can be as complex as you want
-db.select().from(User).where(or(gt(User.id, 1), lt(User.id, 5)))
-```
+Currently supported drivers:
 
-#### Select
+| `PostgreSQL              ` | `import                      ` |
+| -------------------------- | ------------------------------ |
+| pg                         | rado/driver/pg                 |
+| @electric-sql/pglite       | rado/driver/pglite             |
+| @neondatabase/serverless   | rado/driver/pg                 |
+| @vercel/postgres           | rado/driver/pg                 |
 
-Retrieve a single field
+| `SQLite                  ` | `import                      ` |
+| -------------------------- | ------------------------------ |
+| better-sqlite3             | rado/driver/better-sqlite3     |
+| bun:sqlite                 | rado/driver/bun-sqlite         |
+| sql.js                     | rado/driver/sql.js             |
+| @libsql/client             | rado/driver/libsql             |
+| Cloudflare D1              | rado/driver/d1                 |
 
-```ts
-db.select(User.name).from(User)
-```
+| `MySQL                   ` | `import                      ` |
+| -------------------------- | ------------------------------ |
+| mysql2                     | rado/driver/mysql2             |
 
-Or an object of data
+Pass an instance of the database to the `connect` function to get started:
 
 ```ts
-import {eq, include} from 'rado'
-db.select({
-   // Get all user fields: id, username
-  ...User,
-  // Aggregate posts of this user
-  posts: include(db.select().from(Post).where(eq(Post.userId, User.id))) 
-}).from(User)
+import Database from 'better-sqlite3'
+import {connect} from 'rado/driver/better-sqlite3'
+
+const db = connect(new Database('foobar.db'))
 ```
 
-Join other tables and select fields from either table:
+## Querying
 
-```ts
-db
-  .select({
-    username: User.username
-    post: Post
-  })
-  .from(User)
-  .innerJoin(Post, eq(Post.userId, User.id))
-  .where(eq(User.id, 1))
+### Select
+
+Select operations allow you to retrieve data from your database.
+
+```typescript
+// Basic select
+const allUsers = await db.select().from(User)
+
+// Select specific columns
+const userNames = await db.select({id: User.id, name: User.name}).from(User)
 ```
 
-Order, group, limit queries:
+### Where conditions
 
-```ts
-import {asc} from 'rado'
-db.select().from(User)
-  .orderBy(asc(User.username))
-  .groupBy(User.id, User.username)
-  .limit(10, 20)
+Where conditions help you filter your query results.
+
+```typescript
+import {eq, and, or, gt, isNull} from 'rado'
+
+// Simple equality
+const john = await db.select().from(User).where(eq(User.name, 'John'))
+
+// Complex conditions
+const users = await db.select().from(User)
+  .where(
+    gt(User.age, 18),
+    or(
+      eq(User.name, 'Alice'),
+      isNull(User.email)
+    )
+  )
 ```
 
-#### Insert
+### Joins
 
-Insert a single row:
+Joins allow you to combine data from multiple tables.
 
-```ts
-db.insert(User).values({username: 'Mario'})
+```typescript
+const usersWithPosts = await db.select({
+  userName: User.name,
+  postTitle: Post.title,
+})
+.from(User)
+.leftJoin(Post, eq(User.id, Post.authorId))
 ```
 
-Insert multiple rows:
+### Ordering and Grouping
 
-```ts
-db.insert(User).values([{username: 'Mario'}, {username: 'Luigi'}])
+You can order and group your query results:
+
+```typescript
+import {desc, asc, count} from 'rado'
+
+const orderedUsers = await db.select()
+  .from(User)
+  .orderBy(asc(User.name))
+
+const userPostCounts = await db.select({
+  userName: User.name,
+  postCount: count(Post.id)
+})
+.from(User)
+.leftJoin(Post, eq(User.id, Post.authorId))
+.groupBy(User.name)
 ```
 
-#### Update
+### Pagination
 
-Set values
+Pagination helps you manage large datasets by retrieving results in smaller chunks:
 
-```ts
-db.update(User)
-  .set({username: 'Bowser'})
-  .where(eq(User.id, 1))
+```typescript
+const pageSize = 10
+const page = 2
+
+const paginatedUsers = await db.select()
+  .from(User)
+  .limit(pageSize)
+  .offset((page - 1) * pageSize)
 ```
 
-Use expressions to update complex values:
+### JSON columns
 
-```ts
-import {concat} from 'rado/sqlite'
-db.update(User)
-  .set({username: concat(User.username, ' [removed]')})
-  .where(User.deleted)
+Rado provides first-class support for JSON columns:
+
+```typescript
+import {pgTable, serial, text, jsonb} from 'rado/postgres'
+
+const User = pgTable({
+  id: serial().primaryKey(),
+  name: text(),
+  metadata: jsonb<{subscribed: boolean}>()
+})
+
+const subscribedUsers = await db.select()
+  .from(User)
+  .where(eq(User.metadata.subscribed, true))
 ```
 
-#### Delete
+### Subqueries
 
-Delete rows
+```typescript
+const subquery = db.select({authorId: Post.authorId})
+  .from(Post)
+  .groupBy(Post.authorId)
+  .having(gt(count(Post.id), 5))
+  .as('authorIds')
 
-```ts
-db.delete(User).where(eq(User.id, 1))
+const prolificAuthors = await db.select()
+  .from(User)
+  .where(inArray(User.id, subquery))
 ```
 
-## Schema definition
+### Include
 
-```ts
-import * as sqlite from 'rado/sqlite'
-import {sqliteTable as table} from 'rado/sqlite'
+Aggregate rows using the `include` function:
 
-const User = table({
-  id: sqlite.integer().primaryKey(),
-  userName: sqlite.text('user') // Column names are optional
-})
+```typescript
+import {include} from 'rado'
 
-const Post = table({
-  id: sqlite.integer().primaryKey(),
-  userId: sqlite.integer().references(() => User.id),
-  content: sqlite.text()
-})
+const usersWithPosts = await db.select({
+  ...User,
+  posts: include(
+    db.select().from(Post).where(eq(Post.authorId, User.id))
+  )
+}).from(User)
 
-const Tag = table({
-  id: sqlite.integer().primaryKey(),
-  name: sqlite.text()
-})
+// Use include.one for a single related record
+const usersWithLatestPost = await db.select({
+  ...User,
+  latestPost: include.one(
+    db.select()
+      .from(Post)
+      .where(eq(Post.authorId, User.id))
+      .orderBy(desc(Post.createdAt))
+      .limit(1)
+  )
+}).from(User)
+```
 
-const PostTags = table({
-  postId: sqlite.integer().references(() => Post.id),
-  tagId: sqlite.integer().references(() => Tag.id)
-})
+### SQL Operator
+
+The `sql` operator allows you to write raw SQL and interpolate values safely:
+
+```typescript
+import {sql} from 'rado'
+
+const minAge = 18
+const adultUsers = await db.select()
+  .from(User)
+  .where(sql`${User.age} >= ${minAge}`)
 ```
 
-## Connections
+## Modifying Data
 
-Currently supported drivers:
+### Insert
 
-| `PostgreSQL              ` | `import                      ` |
-| -------------------------- | ------------------------------ |
-| `pg`                       | `'rado/driver/pg'`             |
-| `@electric-sql/pglite`     | `'rado/driver/pglite'`         |
-| `@neondatabase/serverless` | `'rado/driver/pg'`             |
-| `@vercel/postgres`         | `'rado/driver/pg'`             |
+Insert operations allow you to add new records to your database:
 
-| `SQLite                  ` | `import                      ` |
-| -------------------------- | ------------------------------ |
-| `better-sqlite3`           | `'rado/driver/better-sqlite3'` |
-| `bun:sqlite`               | `'rado/driver/bun-sqlite'`     |
-| `sql.js`                   | `'rado/driver/sql.js'`         |
-| `Cloudflare D1`            | `'rado/driver/d1'`             |
+```typescript
+// Single insert
+const newUser = await db.insert(User)
+  .values({name: 'Alice', email: 'alice@example.com'})
+  .returning()
 
-| `MySQL                   ` | `import                      ` |
-| -------------------------- | ------------------------------ |
-| `mysql2`                   | `'rado/driver/mysql2'`         |
+// Bulk insert
+const newUsers = await db.insert(User)
+  .values([
+    {name: 'Bob', email: 'bob@example.com'},
+    {name: 'Charlie', email: 'charlie@example.com'},
+  ])
+  .returning()
+```
 
-Pass an instance of the database to the `connect` function to get started:
+### Update
 
-```ts
-import Database from 'better-sqlite3'
-import {connect} from 'rado/driver/better-sqlite3'
+Update operations modify existing records:
 
-const db = connect(new Database('foobar.db'))
+```typescript
+const updatedCount = await db.update(User)
+  .set({name: 'Johnny'})
+  .where(eq(User.name, 'John'))
 ```
 
+### Delete
+
+Delete operations remove records from your database:
 
-#### Run queries
+```typescript
+await db.delete(User).where(eq(User.name, 'John'))
+```
 
-Call the connection with a query to retrieve its results:
+### Transactions
 
-```ts
-// For sync drivers this will be an array:
-const posts = db.select().from(Post).all()
-// For async drivers this will be a Promise:
-const posts = await db.select().from(Post)
+Transactions allow you to group multiple operations into a single atomic unit.
+
+```typescript
+const result = await db.transaction(async (tx) => {
+  const user = await tx.insert(User)
+    .values({ name: 'Alice', email: 'alice@example.com' })
+    .returning()
+  const post = await tx.insert(Post)
+    .values({ title: 'My First Post', authorId: user.id })
+    .returning()
+  return {user, post}
+})
 ```
 
-#### Transactions
+## Universal Queries
 
-Run transactions within the `transaction` method which will isolate a connection
-and can optionally return a result:
+Rado provides a universal query builder that works across different database 
+engines, whether they run synchronously or asynchronously. This is useful for
+writing database-agnostic code.
 
-```ts
-const firstUserId = db.transaction(tx => {
-  const createTable = db.create(User)
-  tx(createTable)
-  const insertUser = db.insert(User).values({username: 'Mario'}).returning(User.id)
-  return tx(insertUser)
+```typescript
+import {table} from 'rado'
+import {id, text} from 'rado/universal'
+
+const User = table('user', {
+  id: id(),
+  name: text() 
 })
+
+const db = process.env.SQLITE ? sqliteDb : postgresDb
+
+const userNames = await db.select(User.name).from(User)
 ```
+
+## Custom Column Types
+
+You can define custom column types, such as a boolean column that is stored as a
+tinyint in the database:
+
+```typescript
+import {Column, column, table, sql} from 'rado'
+
+export function bool(name?: string): Column<boolean | null> {
+  return column({
+    name,
+    type: sql`tinyint(1)`,
+    mapFromDriverValue(value: number): boolean {
+      return value === 1
+    },
+    mapToDriverValue(value: boolean): number {
+      return value ? 1 : 0
+    }
+  })
+}
+
+// Usage
+const User = table('user', {
+  // ...
+  isActive: bool()
+})
+```

package/dist/core/Dialect.d.ts

@@ -1,8 +1,10 @@
 import type { Emitter } from './Emitter.js';
 import { type HasQuery, type HasSql } from './Internal.js';
+import type { Runtime } from './MetaData.js';
 export declare class Dialect {
     #private;
-    constructor(createEmitter: new () => Emitter);
+    runtime: Runtime;
+    constructor(runtime: Runtime, createEmitter: new (runtime: Runtime) => Emitter);
     emit: (input: HasSql | HasQuery) => Emitter;
     inline: (input: HasSql | HasQuery) => string;
 }

package/dist/core/Dialect.js

@@ -5,19 +5,21 @@ import {
   hasQuery
 } from "./Internal.js";
 var Dialect = class {
+  runtime;
   #createEmitter;
-  constructor(createEmitter) {
+  constructor(runtime, createEmitter) {
+    this.runtime = runtime;
     this.#createEmitter = createEmitter;
   }
   emit = (input) => {
     const sql = hasQuery(input) ? getQuery(input) : getSql(input);
-    const emitter = new this.#createEmitter();
+    const emitter = new this.#createEmitter(this.runtime);
     sql.emitTo(emitter);
     return emitter;
   };
   inline = (input) => {
     const sql = hasQuery(input) ? getQuery(input) : getSql(input);
-    const emitter = new this.#createEmitter();
+    const emitter = new this.#createEmitter(this.runtime);
     sql.inlineValues().emitTo(emitter);
     return emitter.sql;
   };

package/dist/core/Driver.d.ts

@@ -8,6 +8,7 @@ export interface BatchQuery {
 }
 export interface DriverSpecs {
     parsesJson: boolean;
+    supportsTransactions: boolean;
 }
 export interface PrepareOptions {
     isSelection: boolean;

package/dist/core/Emitter.d.ts

@@ -13,17 +13,18 @@ import type { SelectData } from './query/Select.js';
 import type { UnionData } from './query/Union.js';
 import type { Update } from './query/Update.js';
 export declare abstract class Emitter {
+    #private;
     sql: string;
     protected params: Array<Param>;
-    get hasParams(): boolean;
-    bind(inputs?: Record<string, unknown>): Array<unknown>;
-    processValue(value: unknown): unknown;
-    abstract runtime: Runtime;
     abstract emitIdentifier(value: string): void;
     abstract emitValue(value: unknown): void;
     abstract emitInline(value: unknown): void;
     abstract emitJsonPath(path: JsonPath): void;
     abstract emitPlaceholder(value: string): void;
+    constructor(runtime: Runtime);
+    get hasParams(): boolean;
+    bind(inputs?: Record<string, unknown>): Array<unknown>;
+    processValue(value: unknown): unknown;
     emitIdentifierOrSelf(value: string): void;
     selfName?: string;
     emitSelf({ name, inner }: {

package/dist/core/Emitter.js

@@ -10,8 +10,12 @@ import { Sql, sql } from "./Sql.js";
 import { callFunction } from "./expr/Functions.js";
 import { jsonAggregateArray, jsonArray } from "./expr/Json.js";
 var Emitter = class {
+  #runtime;
   sql = "";
   params = [];
+  constructor(runtime) {
+    this.#runtime = runtime;
+  }
   get hasParams() {
     return this.params.length > 0;
   }
@@ -85,7 +89,15 @@ var Emitter = class {
     }).emitTo(this);
   }
   emitInsert(insert) {
-    const { cte, into, values, select, onConflict, returning } = getData(insert);
+    const {
+      cte,
+      into,
+      values,
+      select,
+      onConflict,
+      onDuplicateKeyUpdate,
+      returning
+    } = getData(insert);
     if (cte) this.emitWith(cte);
     const table = getTable(into);
     const tableName = sql.identifier(table.name);
@@ -93,6 +105,7 @@ var Emitter = class {
       insertInto: sql`${tableName}(${table.listColumns()})`,
       ...values ? { values } : { "": select },
       onConflict,
+      onDuplicateKeyUpdate,
       returning
     }).inlineFields(false).emitTo(this);
   }
@@ -160,7 +173,7 @@ var Emitter = class {
     sql`(select ${data.first ? subject : jsonAggregateArray(subject)} from (${inner}) as _)`.emitTo(this);
   }
   emitUniversal(runtimes) {
-    const sql2 = runtimes[this.runtime] ?? runtimes.default;
+    const sql2 = runtimes[this.#runtime] ?? runtimes.default;
     if (!sql2) throw new Error("Unsupported runtime");
     sql2.emitTo(this);
   }

package/dist/core/query/Insert.d.ts

@@ -1,5 +1,5 @@
 import { type HasSql, type HasTable, internalData, internalQuery, internalSelection } from '../Internal.js';
-import type { IsPostgres, IsSqlite, QueryMeta } from '../MetaData.js';
+import type { IsMysql, IsPostgres, IsSqlite, QueryMeta } from '../MetaData.js';
 import { Query, type QueryData } from '../Query.js';
 import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.js';
 import { type Sql } from '../Sql.js';
@@ -12,6 +12,7 @@ interface InsertIntoData<Meta extends QueryMeta> extends QueryData<Meta> {
 export interface InsertData<Meta extends QueryMeta> extends InsertIntoData<Meta> {
     returning?: Selection;
     onConflict?: HasSql;
+    onDuplicateKeyUpdate?: HasSql;
 }
 export declare class Insert<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> {
     readonly [internalData]: InsertData<Meta>;
@@ -27,14 +28,17 @@ export interface OnConflict {
     target: HasSql | Array<HasSql>;
     targetWhere?: HasSql<boolean>;
 }
-export interface OnConflictUpdate<Definition extends TableDefinition> extends OnConflict {
+export interface OnConflictSet<Definition extends TableDefinition> {
     set: TableUpdate<Definition>;
+}
+export interface OnConflictUpdate<Definition extends TableDefinition> extends OnConflict, OnConflictSet<Definition> {
     setWhere?: HasSql<boolean>;
 }
 declare class InsertCanConflict<Definition extends TableDefinition, Meta extends QueryMeta> extends InsertCanReturn<Definition, Meta> {
     #private;
-    onConflictDoNothing(this: InsertCanConflict<Definition, IsPostgres>, onConflict?: OnConflict): InsertCanReturn<Definition, Meta>;
-    onConflictDoUpdate(this: InsertCanConflict<Definition, IsPostgres>, onConflict: OnConflictUpdate<Definition>): InsertCanReturn<Definition, Meta>;
+    onConflictDoNothing(this: InsertCanConflict<Definition, IsPostgres | IsSqlite>, onConflict?: OnConflict): InsertCanReturn<Definition, Meta>;
+    onConflictDoUpdate(this: InsertCanConflict<Definition, IsPostgres | IsSqlite>, onConflict: OnConflictUpdate<Definition>): InsertCanReturn<Definition, Meta>;
+    onDuplicateKeyUpdate(this: InsertCanConflict<Definition, IsMysql>, update: OnConflictSet<Definition>): InsertCanReturn<Definition, Meta>;
 }
 export declare class InsertInto<Definition extends TableDefinition, Meta extends QueryMeta> {
     [internalData]: InsertData<Meta>;

package/dist/core/query/Insert.js

@@ -40,18 +40,27 @@ var InsertCanConflict = class extends InsertCanReturn {
   onConflictDoUpdate(onConflict) {
     return this.#onConflict(onConflict);
   }
+  onDuplicateKeyUpdate(update) {
+    return new InsertCanReturn({
+      ...getData(this),
+      onDuplicateKeyUpdate: this.#updateFields(update.set)
+    });
+  }
+  #updateFields(update) {
+    return sql.join(
+      Object.entries(update).map(
+        ([key, value]) => sql`${sql.identifier(key)} = ${input(value)}`
+      ),
+      sql`, `
+    );
+  }
   #onConflict({
     target,
     targetWhere,
     set,
     setWhere
   }) {
-    const update = set && sql.join(
-      Object.entries(set).map(
-        ([key, value]) => sql`${sql.identifier(key)} = ${input(value)}`
-      ),
-      sql`, `
-    );
+    const update = set && this.#updateFields(set);
     return new InsertCanReturn({
       ...getData(this),
       onConflict: sql.join([

package/dist/driver/better-sqlite3.js

@@ -32,6 +32,7 @@ var BetterSqlite3Driver = class _BetterSqlite3Driver {
     this.depth = depth;
   }
   parsesJson = false;
+  supportsTransactions = true;
   exec(query) {
     this.client.exec(query);
   }

package/dist/driver/bun-sqlite.js

@@ -29,6 +29,7 @@ var BunSqliteDriver = class _BunSqliteDriver {
     this.depth = depth;
   }
   parsesJson = false;
+  supportsTransactions = true;
   exec(query) {
     this.client.exec(query);
   }

package/dist/driver/d1.d.ts

@@ -14,6 +14,7 @@ declare class PreparedStatement implements AsyncStatement {
 export declare class D1Driver implements AsyncDriver {
     private client;
     parsesJson: boolean;
+    supportsTransactions: boolean;
     constructor(client: Client);
     exec(query: string): Promise<void>;
     prepare(sql: string, options: PrepareOptions): PreparedStatement;

package/dist/driver/d1.js

@@ -17,11 +17,7 @@ var PreparedStatement = class {
     return this.stmt.bind(...params).first();
   }
   async values(params) {
-    if (this.isSelection) {
-      const results = await this.stmt.bind(...params).raw();
-      console.log(results);
-      return results;
-    }
+    if (this.isSelection) return this.stmt.bind(...params).raw();
     await this.stmt.bind(...params).run();
     return [];
   }
@@ -33,6 +29,7 @@ var D1Driver = class {
     this.client = client;
   }
   parsesJson = false;
+  supportsTransactions = false;
   async exec(query) {
     await this.client.exec(query);
   }
@@ -42,10 +39,11 @@ var D1Driver = class {
   async close() {
   }
   async batch(queries) {
-    const results = [];
-    for (const { sql, params, isSelection } of queries)
-      results.push(await this.prepare(sql, { isSelection }).values(params));
-    return results;
+    const stmts = queries.map(
+      ({ sql, params }) => this.client.prepare(sql).bind(...params)
+    );
+    const rows = await this.client.batch(stmts);
+    return rows.map((row) => row.results);
   }
   async transaction() {
     throw new Error("Transactions are not supported in D1");

package/dist/driver/libsql.d.ts

@@ -0,0 +1,28 @@
+import type { Client, InValue, Transaction } from '@libsql/client';
+import { AsyncDatabase, type TransactionOptions } from '../core/Database.js';
+import type { AsyncDriver, AsyncStatement, BatchQuery, PrepareOptions } from '../core/Driver.js';
+type Queryable = Client | Transaction;
+declare class PreparedStatement implements AsyncStatement {
+    private client;
+    private sql;
+    constructor(client: Queryable, sql: string);
+    all(params: Array<InValue>): Promise<Array<object>>;
+    run(params: Array<InValue>): Promise<void>;
+    get(params: Array<InValue>): Promise<object | null>;
+    values(params: Array<InValue>): Promise<Array<Array<unknown>>>;
+    free(): void;
+}
+export declare class LibSQLClient implements AsyncDriver {
+    private client;
+    private depth;
+    parsesJson: boolean;
+    supportsTransactions: boolean;
+    constructor(client: Queryable, depth?: number);
+    exec(query: string): Promise<void>;
+    prepare(sql: string, options: PrepareOptions): PreparedStatement;
+    close(): Promise<void>;
+    batch(queries: Array<BatchQuery>): Promise<Array<Array<unknown>>>;
+    transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['sqlite']): Promise<T>;
+}
+export declare function connect(client: Client): AsyncDatabase<'sqlite'>;
+export {};

package/dist/driver/libsql.js

@@ -0,0 +1,76 @@
+// src/driver/libsql.ts
+import { AsyncDatabase } from "../core/Database.js";
+import { sqliteDialect } from "../sqlite.js";
+import { sqliteDiff } from "../sqlite/diff.js";
+var PreparedStatement = class {
+  constructor(client, sql) {
+    this.client = client;
+    this.sql = sql;
+  }
+  async all(params) {
+    const result = await this.client.execute({ sql: this.sql, args: params });
+    return result.rows;
+  }
+  async run(params) {
+    const result = await this.client.execute({ sql: this.sql, args: params });
+  }
+  async get(params) {
+    return (await this.all(params))[0] ?? null;
+  }
+  async values(params) {
+    const result = await this.client.execute({ sql: this.sql, args: params });
+    return result.rows;
+  }
+  free() {
+  }
+};
+var LibSQLClient = class _LibSQLClient {
+  constructor(client, depth = 0) {
+    this.client = client;
+    this.depth = depth;
+  }
+  parsesJson = false;
+  supportsTransactions = true;
+  async exec(query) {
+    await this.client.execute(query);
+  }
+  prepare(sql, options) {
+    return new PreparedStatement(this.client, sql);
+  }
+  async close() {
+    if ("close" in this.client) return this.client.close();
+  }
+  async batch(queries) {
+    const stmts = queries.map(({ sql, params }) => {
+      return { sql, args: params };
+    });
+    const rows = await this.client.batch(stmts);
+    return rows.map((row) => row.rows);
+  }
+  async transaction(run, options) {
+    const client = "transaction" in this.client ? await this.client.transaction() : this.client;
+    const driver = new _LibSQLClient(client, this.depth + 1);
+    if (this.depth > 0) await client.execute(`savepoint d${this.depth}`);
+    try {
+      const result = await run(driver);
+      if (this.depth > 0)
+        await client.execute(`release savepoint d${this.depth}`);
+      else await client.commit();
+      return result;
+    } catch (error) {
+      if (this.depth > 0)
+        await client.execute(`rollback to savepoint d${this.depth}`);
+      else await client.rollback();
+      throw error;
+    } finally {
+      if (this.depth === 0) client.close();
+    }
+  }
+};
+function connect(client) {
+  return new AsyncDatabase(new LibSQLClient(client), sqliteDialect, sqliteDiff);
+}
+export {
+  LibSQLClient,
+  connect
+};

package/dist/driver/mysql2.d.ts

@@ -19,6 +19,7 @@ export declare class Mysql2Driver implements AsyncDriver {
     private client;
     private depth;
     parsesJson: boolean;
+    supportsTransactions: boolean;
     constructor(client: Queryable, depth?: number);
     exec(query: string): Promise<void>;
     prepare(sql: string, options?: PrepareOptions): PreparedStatement;

package/dist/driver/mysql2.js

@@ -38,6 +38,7 @@ var Mysql2Driver = class _Mysql2Driver {
     this.depth = depth;
   }
   parsesJson = true;
+  supportsTransactions = true;
   async exec(query) {
     await this.client.query(query);
   }

package/dist/driver/pg.d.ts

@@ -17,6 +17,7 @@ export declare class PgDriver implements AsyncDriver {
     private client;
     private depth;
     parsesJson: boolean;
+    supportsTransactions: boolean;
     constructor(client: Queryable, depth?: number);
     exec(query: string): Promise<void>;
     prepare(sql: string, options?: PrepareOptions): PreparedStatement;

package/dist/driver/pg.js

@@ -46,6 +46,7 @@ var PgDriver = class _PgDriver {
     this.depth = depth;
   }
   parsesJson = true;
+  supportsTransactions = true;
   async exec(query) {
     await this.client.query(query);
   }

package/dist/driver/pglite.d.ts

@@ -16,6 +16,7 @@ export declare class PGliteDriver implements AsyncDriver {
     private client;
     private depth;
     parsesJson: boolean;
+    supportsTransactions: boolean;
     constructor(client: Queryable, depth?: number);
     exec(query: string): Promise<void>;
     close(): Promise<void>;

package/dist/driver/pglite.js

@@ -35,6 +35,7 @@ var PGliteDriver = class _PGliteDriver {
     this.depth = depth;
   }
   parsesJson = true;
+  supportsTransactions = true;
   async exec(query) {
     await this.client.exec(query);
   }

package/dist/driver/sql.js.js

@@ -42,6 +42,7 @@ var SqlJsDriver = class _SqlJsDriver {
     this.depth = depth;
   }
   parsesJson = false;
+  supportsTransactions = true;
   exec(query) {
     this.client.exec(query);
   }

package/dist/driver.d.ts

@@ -1,6 +1,7 @@
 export { connect as 'better-sqlite3' } from './driver/better-sqlite3.js';
 export { connect as 'bun:sqlite' } from './driver/bun-sqlite.js';
 export { connect as 'd1' } from './driver/d1.js';
+export { connect as '@libsql/client' } from './driver/libsql.js';
 export { connect as 'mysql2' } from './driver/mysql2.js';
 export { connect as '@neondatabase/serverless', connect as '@vercel/postgres', connect as 'pg' } from './driver/pg.js';
 export { connect as '@electric-sql/pglite' } from './driver/pglite.js';

package/dist/driver.js

@@ -2,22 +2,24 @@
 import { connect } from "./driver/better-sqlite3.js";
 import { connect as connect2 } from "./driver/bun-sqlite.js";
 import { connect as connect3 } from "./driver/d1.js";
-import { connect as connect4 } from "./driver/mysql2.js";
+import { connect as connect4 } from "./driver/libsql.js";
+import { connect as connect5 } from "./driver/mysql2.js";
 import {
-  connect as connect5,
   connect as connect6,
-  connect as connect7
+  connect as connect7,
+  connect as connect8
 } from "./driver/pg.js";
-import { connect as connect8 } from "./driver/pglite.js";
-import { connect as connect9 } from "./driver/sql.js.js";
+import { connect as connect9 } from "./driver/pglite.js";
+import { connect as connect10 } from "./driver/sql.js.js";
 export {
-  connect8 as "@electric-sql/pglite",
-  connect5 as "@neondatabase/serverless",
-  connect6 as "@vercel/postgres",
+  connect9 as "@electric-sql/pglite",
+  connect4 as "@libsql/client",
+  connect6 as "@neondatabase/serverless",
+  connect7 as "@vercel/postgres",
   connect as "better-sqlite3",
   connect2 as "bun:sqlite",
   connect3 as d1,
-  connect4 as mysql2,
-  connect7 as pg,
-  connect9 as "sql.js"
+  connect5 as mysql2,
+  connect8 as pg,
+  connect10 as "sql.js"
 };

package/dist/mysql/dialect.js

@@ -9,6 +9,7 @@ var SINGLE_QUOTE = "'";
 var ESCAPE_SINGLE_QUOTE = "''";
 var MATCH_SINGLE_QUOTE = /'/g;
 var mysqlDialect = new Dialect(
+  "mysql",
   class extends Emitter {
     runtime = "mysql";
     paramIndex = 0;

package/dist/postgres/dialect.js

@@ -9,6 +9,7 @@ var SINGLE_QUOTE = "'";
 var ESCAPE_SINGLE_QUOTE = "''";
 var MATCH_SINGLE_QUOTE = /'/g;
 var postgresDialect = new Dialect(
+  "postgres",
   class extends Emitter {
     runtime = "postgres";
     paramIndex = 0;

package/dist/sqlite/dialect.js

@@ -9,8 +9,8 @@ var SINGLE_QUOTE = "'";
 var ESCAPE_SINGLE_QUOTE = "''";
 var MATCH_SINGLE_QUOTE = /'/g;
 var sqliteDialect = new Dialect(
+  "sqlite",
   class extends Emitter {
-    runtime = "sqlite";
     processValue(value) {
       return typeof value === "boolean" ? value ? 1 : 0 : value;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -30,6 +30,7 @@
     "@biomejs/biome": "^1.8.3",
     "@cloudflare/workers-types": "^4.20230628.0",
     "@electric-sql/pglite": "^0.1.5",
+    "@libsql/client": "^0.10.0",
     "@miniflare/d1": "^2.14.2",
     "@miniflare/shared": "^2.14.2",
     "@sqlite.org/sqlite-wasm": "^3.42.0-build4",