rado 1.0.9 → 1.0.11

package/README.md

@@ -5,191 +5,329 @@
 
 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
+
+```typescript
+import {table} from 'rado'
+import {text, integer} from 'rado/postgres'
+import {connect} from 'rado/driver/pg'
+import {Pool} from 'pg'
 
-#### Where
+// Define your schema
+const User = table({
+  id: integer().primaryKey(),
+  name: text().notNull(),
+  email: text().unique()
+})
 
-Conditions can be created by accessing the fields of the table:
+// Connect to the database
+const db = connect(new Pool({
+  host: 'localhost',
+  database: 'my_database'
+}))
 
-```ts
-import {eq} from 'rado'
-eq(User.id, 1) // Compare with a value
-eq(User.id, Post.userId) // Compare to fields on other tables
+// 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
+
+Currently supported drivers:
+
+| `PostgreSQL              ` | `import                      ` |
+| -------------------------- | ------------------------------ |
+| `pg`                       | `'rado/driver/pg'`             |
+| `@electric-sql/pglite`     | `'rado/driver/pglite'`         |
+| `@neondatabase/serverless` | `'rado/driver/pg'`             |
+| `@vercel/postgres`         | `'rado/driver/pg'`             |
+
+| `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'`             |
+
+| `MySQL                   ` | `import                      ` |
+| -------------------------- | ------------------------------ |
+| `mysql2`                   | `'rado/driver/mysql2'`         |
+
+Pass an instance of the database to the `connect` function to get started:
 
 ```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)))
+import Database from 'better-sqlite3'
+import {connect} from 'rado/driver/better-sqlite3'
+
+const db = connect(new Database('foobar.db'))
 ```
 
-#### Select
+## Querying
 
-Retrieve a single field
+### Select
 
-```ts
-db.select(User.name).from(User)
+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)
 ```
 
-Or an object of data
+### Where conditions
 
-```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)
+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)
+    )
+  )
 ```
 
-Join other tables and select fields from either table:
+### Joins
 
-```ts
-db
-  .select({
-    username: User.username
-    post: Post
-  })
-  .from(User)
-  .innerJoin(Post, eq(Post.userId, User.id))
-  .where(eq(User.id, 1))
+Joins allow you to combine data from multiple tables.
+
+```typescript
+const usersWithPosts = await db.select({
+  userName: User.name,
+  postTitle: Post.title,
+})
+.from(User)
+.leftJoin(Post, eq(User.id, Post.authorId))
 ```
 
-Order, group, limit queries:
+### Ordering and Grouping
 
-```ts
-import {asc} from 'rado'
-db.select().from(User)
-  .orderBy(asc(User.username))
-  .groupBy(User.id, User.username)
-  .limit(10, 20)
+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)
 ```
 
-#### Insert
+### Pagination
 
-Insert a single row:
+Pagination helps you manage large datasets by retrieving results in smaller chunks:
 
-```ts
-db.insert(User).values({username: 'Mario'})
+```typescript
+const pageSize = 10
+const page = 2
+
+const paginatedUsers = await db.select()
+  .from(User)
+  .limit(pageSize)
+  .offset((page - 1) * pageSize)
 ```
 
-Insert multiple rows:
+### JSON columns
 
-```ts
-db.insert(User).values([{username: 'Mario'}, {username: 'Luigi'}])
+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))
 ```
 
-#### Update
+### Subqueries
 
-Set values
+```typescript
+const subquery = db.select({authorId: Post.authorId})
+  .from(Post)
+  .groupBy(Post.authorId)
+  .having(gt(count(Post.id), 5))
+  .as('authorIds')
 
-```ts
-db.update(User)
-  .set({username: 'Bowser'})
-  .where(eq(User.id, 1))
+const prolificAuthors = await db.select()
+  .from(User)
+  .where(inArray(User.id, subquery))
 ```
 
-Use expressions to update complex values:
+### Include
 
-```ts
-import {concat} from 'rado/sqlite'
-db.update(User)
-  .set({username: concat(User.username, ' [removed]')})
-  .where(User.deleted)
+Aggregate rows using the `include` function:
+
+```typescript
+import {include} from 'rado'
+
+const usersWithPosts = await db.select({
+  ...User,
+  posts: include(
+    db.select().from(Post).where(eq(Post.authorId, User.id))
+  )
+}).from(User)
+
+// 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)
 ```
 
-#### Delete
+### SQL Operator
 
-Delete rows
+The `sql` operator allows you to write raw SQL and interpolate values safely:
 
-```ts
-db.delete(User).where(eq(User.id, 1))
+```typescript
+import {sql} from 'rado'
+
+const minAge = 18
+const adultUsers = await db.select()
+  .from(User)
+  .where(sql`${User.age} >= ${minAge}`)
 ```
 
-## Schema definition
+## Modifying Data
 
-```ts
-import * as sqlite from 'rado/sqlite'
-import {sqliteTable as table} from 'rado/sqlite'
+### Insert
 
-const User = table({
-  id: sqlite.integer().primaryKey(),
-  userName: sqlite.text('user') // Column names are optional
-})
+Insert operations allow you to add new records to your database:
 
-const Post = table({
-  id: sqlite.integer().primaryKey(),
-  userId: sqlite.integer().references(() => User.id),
-  content: sqlite.text()
-})
+```typescript
+// Single insert
+const newUser = await db.insert(User)
+  .values({name: 'Alice', email: 'alice@example.com'})
+  .returning()
 
-const Tag = table({
-  id: sqlite.integer().primaryKey(),
-  name: sqlite.text()
-})
+// Bulk insert
+const newUsers = await db.insert(User)
+  .values([
+    {name: 'Bob', email: 'bob@example.com'},
+    {name: 'Charlie', email: 'charlie@example.com'},
+  ])
+  .returning()
+```
 
-const PostTags = table({
-  postId: sqlite.integer().references(() => Post.id),
-  tagId: sqlite.integer().references(() => Tag.id)
-})
+### Update
+
+Update operations modify existing records:
+
+```typescript
+const updatedCount = await db.update(User)
+  .set({name: 'Johnny'})
+  .where(eq(User.name, 'John'))
 ```
 
-## Connections
+### Delete
 
-Currently supported drivers:
+Delete operations remove records from your database:
 
-| Driver           | import                         |
-| ---------------- | ------------------------------ |
-| `better-sqlite3` | `'rado/driver/better-sqlite3'` |
-| `bun-sqlite`     | `'rado/driver/bun-sqlite'`     |
-| `mysql2`         | `'rado/driver/mysql2'`         |
-| `pg`             | `'rado/driver/pg'`             |
-| `pglite`         | `'rado/driver/pglite'`         |
-| `sql.js`         | `'rado/driver/sql.js'`         |
+```typescript
+await db.delete(User).where(eq(User.name, 'John'))
+```
 
-Pass an instance of the database to the `connect` function to get started:
+### Transactions
 
-```ts
-import Database from 'better-sqlite3'
-import {connect} from 'rado/driver/better-sqlite3'
+Transactions allow you to group multiple operations into a single atomic unit.
 
-const db = connect(new Database('foobar.db'))
+```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}
+})
 ```
 
+## Universal Queries
 
-#### Run queries
+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.
 
-Call the connection with a query to retrieve its results:
+```typescript
+import {table} from 'rado'
+import {id, text} from 'rado/universal'
 
-```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)
+const User = table('user', {
+  id: id(),
+  name: text() 
+})
+
+const db = process.env.SQLITE ? sqliteDb : postgresDb
+
+const userNames = await db.select(User.name).from(User)
 ```
 
-#### Transactions
+## Custom Column Types
 
-Run transactions within the `transaction` method which will isolate a connection
-and can optionally return a result:
+You can define custom column types, such as a boolean column that is stored as a
+tinyint in the database:
 
-```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 {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.js

@@ -26,9 +26,13 @@ var Executable = class {
     return this.#execute();
   }
   // biome-ignore lint/suspicious/noThenProperty:
-  then(onfulfilled, onrejected) {
-    const result = this.#execute();
-    return Promise.resolve(result).then(onfulfilled, onrejected);
+  async then(onfulfilled, onrejected) {
+    try {
+      const result = await this.#execute();
+      return onfulfilled ? onfulfilled(result) : result;
+    } catch (error) {
+      return onrejected ? onrejected(error) : Promise.reject(error);
+    }
   }
   catch(onrejected) {
     return this.then().catch(onrejected);

package/dist/core/expr/Include.js

@@ -13,8 +13,10 @@ var Include = class {
   #mapFromDriverValue = (value, specs) => {
     const { select, first } = getData(this);
     const parsed = specs.parsesJson ? value : JSON.parse(value);
-    if (first)
-      return parsed ? select.mapRow({ values: parsed, index: 0, specs }) : null;
+    if (first) {
+      const result = parsed ? select.mapRow({ values: parsed, index: 0, specs }) : null;
+      return result;
+    }
     if (!parsed) return [];
     const rows = parsed;
     const ctx = {

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

@@ -18,7 +18,8 @@ var PreparedStatement = class {
     return this.stmt.get(...params);
   }
   values(params) {
-    if (this.isSelection) return this.stmt.raw(true).all(...params);
+    if (this.isSelection)
+      return this.stmt.raw(true).all(...params);
     this.stmt.run(...params);
     return [];
   }
@@ -31,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

@@ -0,0 +1,26 @@
+import { AsyncDatabase } from '../core/Database.js';
+import type { AsyncDriver, AsyncStatement, BatchQuery, PrepareOptions } from '../core/Driver.js';
+type Client = D1Database;
+declare class PreparedStatement implements AsyncStatement {
+    private stmt;
+    private isSelection;
+    constructor(stmt: D1PreparedStatement, isSelection: boolean);
+    all(params: Array<unknown>): Promise<Array<object>>;
+    run(params: Array<unknown>): Promise<void>;
+    get(params: Array<unknown>): Promise<object | null>;
+    values(params: Array<unknown>): Promise<Array<Array<unknown>>>;
+    free(): void;
+}
+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;
+    close(): Promise<void>;
+    batch(queries: Array<BatchQuery>): Promise<Array<Array<unknown>>>;
+    transaction<T>(): Promise<T>;
+}
+export declare function connect(client: Client): AsyncDatabase<'sqlite'>;
+export {};

package/dist/driver/d1.js

@@ -0,0 +1,58 @@
+// src/driver/d1.ts
+import { AsyncDatabase } from "../core/Database.js";
+import { sqliteDialect } from "../sqlite.js";
+import { sqliteDiff } from "../sqlite/diff.js";
+var PreparedStatement = class {
+  constructor(stmt, isSelection) {
+    this.stmt = stmt;
+    this.isSelection = isSelection;
+  }
+  async all(params) {
+    return this.stmt.bind(...params).all().then(({ results }) => results);
+  }
+  async run(params) {
+    const results = await this.stmt.bind(...params).run();
+  }
+  async get(params) {
+    return this.stmt.bind(...params).first();
+  }
+  async values(params) {
+    if (this.isSelection) return this.stmt.bind(...params).raw();
+    await this.stmt.bind(...params).run();
+    return [];
+  }
+  free() {
+  }
+};
+var D1Driver = class {
+  constructor(client) {
+    this.client = client;
+  }
+  parsesJson = false;
+  supportsTransactions = false;
+  async exec(query) {
+    await this.client.exec(query);
+  }
+  prepare(sql, options) {
+    return new PreparedStatement(this.client.prepare(sql), options.isSelection);
+  }
+  async close() {
+  }
+  async batch(queries) {
+    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");
+  }
+};
+function connect(client) {
+  return new AsyncDatabase(new D1Driver(client), sqliteDialect, sqliteDiff);
+}
+export {
+  D1Driver,
+  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

@@ -1,6 +1,6 @@
 import type { PGlite, Transaction } from '@electric-sql/pglite';
+import { AsyncDatabase, type TransactionOptions } from '../core/Database.js';
 import type { AsyncDriver, AsyncStatement, BatchQuery } from '../core/Driver.js';
-import { AsyncDatabase, type TransactionOptions } from '../index.js';
 type Queryable = PGlite | Transaction;
 declare class PreparedStatement implements AsyncStatement {
     private client;
@@ -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

@@ -1,5 +1,5 @@
 // src/driver/pglite.ts
-import { AsyncDatabase } from "../index.js";
+import { AsyncDatabase } from "../core/Database.js";
 import { postgresDialect } from "../postgres/dialect.js";
 import { postgresDiff } from "../postgres/diff.js";
 import { setTransaction } from "../postgres/transactions.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

@@ -0,0 +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 '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';
+export { connect as 'sql.js' } from './driver/sql.js.js';

package/dist/driver.js

@@ -0,0 +1,23 @@
+// src/driver.ts
+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 connect5,
+  connect as connect6,
+  connect as connect7
+} from "./driver/pg.js";
+import { connect as connect8 } from "./driver/pglite.js";
+import { connect as connect9 } from "./driver/sql.js.js";
+export {
+  connect8 as "@electric-sql/pglite",
+  connect5 as "@neondatabase/serverless",
+  connect6 as "@vercel/postgres",
+  connect as "better-sqlite3",
+  connect2 as "bun:sqlite",
+  connect3 as d1,
+  connect4 as mysql2,
+  connect7 as pg,
+  connect9 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/dist/universal/columns.d.ts

@@ -1,4 +1,4 @@
-import { JsonColumn, type Column } from '../core/Column.js';
+import { type Column, JsonColumn } from '../core/Column.js';
 export declare function id(name?: string): Column<number>;
 export declare function text(name?: string): Column<string | null>;
 export declare function varchar(name?: string, options?: {

package/dist/universal/columns.js

@@ -69,7 +69,13 @@ function jsonb(name) {
   });
 }
 function blob(name) {
-  return column({ name, type: blobType });
+  return column({
+    name,
+    type: blobType,
+    mapFromDriverValue(value) {
+      return new Uint8Array(value);
+    }
+  });
 }
 export {
   blob,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -11,7 +11,7 @@
     "cycles": "madge --circular src/index.ts src/sqlite.ts src/mysql.ts src/postgres.ts",
     "test:bun": "bun test",
     "test:node": "node --test-force-exit --test-concurrency=1 --import tsx --test \"**/*.test.ts\"",
-    "test:deno": "deno test --no-check --allow-read"
+    "test:deno": "deno test --no-check -A --unstable-ffi"
   },
   "sideEffects": false,
   "exports": {
@@ -26,16 +26,20 @@
   },
   "files": ["dist"],
   "devDependencies": {
+    "@alinea/suite": "^0.4.0",
     "@biomejs/biome": "^1.8.3",
     "@cloudflare/workers-types": "^4.20230628.0",
     "@electric-sql/pglite": "^0.1.5",
+    "@miniflare/d1": "^2.14.2",
+    "@miniflare/shared": "^2.14.2",
     "@sqlite.org/sqlite-wasm": "^3.42.0-build4",
-    "@types/better-sqlite3": "^5.4.1",
-    "@types/bun": "^1.1.6",
-    "@types/glob": "^8.0.0",
-    "@types/pg": "^8.11.5",
-    "@types/sql.js": "^1.4.2",
-    "better-sqlite3": "^11.2.1",
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/bun": "^1.1.8",
+    "@types/glob": "^8.1.0",
+    "@types/pg": "^8.11.8",
+    "@types/sql.js": "^1.4.9",
+    "@vercel/postgres": "^0.10.0",
+    "better-sqlite3": "^11.3.0",
     "esbuild": "^0.23.1",
     "glob": "^11.0.0",
     "madge": "^8.0.0",
@@ -45,7 +49,6 @@
     "sql.js": "^1.11.0",
     "sqlite3": "^5.1.7",
     "tsx": "^4.19.0",
-    "typescript": "^5.5.4",
-    "@alinea/suite": "^0.4.0"
+    "typescript": "^5.6.2"
   }
 }