rado 1.0.8 → 1.0.10

package/README.md

@@ -1,4 +1,5 @@
 [![npm](https://img.shields.io/npm/v/rado.svg)](https://npmjs.org/package/rado)
+[![jsr](https://jsr.io/badges/@rado/rado)](https://jsr.io/@rado/rado)
 
 # rado
 
@@ -149,14 +150,23 @@ const PostTags = table({
 
 Currently supported drivers:
 
-| 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'`         |
+| `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:
 

package/dist/core/Column.js

@@ -68,10 +68,9 @@ var column = new Proxy(createColumn, {
   get(target, method) {
     return target[method] ??= (...args) => {
       while (args.length > 0)
-        if (args.at(-1) === void 0)
-          args.pop();
-      if (args.length === 0)
-        return sql.unsafe(method);
+        if (args.at(-1) === void 0) args.pop();
+        else break;
+      if (args.length === 0) return sql.unsafe(method);
       return sql`${sql.unsafe(method)}(${sql.join(
         args.map(sql.inline),
         sql`, `

package/dist/core/Database.js

@@ -49,8 +49,7 @@ var Database = class extends Builder {
       txGenerator(function* (tx) {
         for (const table of tables) {
           const diff = yield* computeDiff(table);
-          if (diff.length > 0)
-            yield* tx.batch(diff.map(sql.unsafe));
+          if (diff.length > 0) yield* tx.batch(diff.map(sql.unsafe));
         }
       })
     );
@@ -60,8 +59,7 @@ var Database = class extends Builder {
   }
   execute(input) {
     const emitter = this.dialect.emit(input);
-    if (emitter.hasParams)
-      throw new Error("Query has parameters");
+    if (emitter.hasParams) throw new Error("Query has parameters");
     return this.driver.exec(emitter.sql);
   }
   transaction(run, options = {}) {

package/dist/core/Emitter.js

@@ -17,8 +17,7 @@ var Emitter = class {
   }
   bind(inputs) {
     return this.params.map((param) => {
-      if (param instanceof ValueParam)
-        return this.processValue(param.value);
+      if (param instanceof ValueParam) return this.processValue(param.value);
       if (inputs && param.name in inputs)
         return this.processValue(inputs[param.name]);
       throw new Error(`Missing input for named parameter: ${param.name}`);
@@ -29,8 +28,7 @@ var Emitter = class {
   }
   emitIdentifierOrSelf(value) {
     if (value === Sql.SELF_TARGET) {
-      if (!this.selfName)
-        throw new Error("Self target not defined");
+      if (!this.selfName) throw new Error("Self target not defined");
       this.emitIdentifier(this.selfName);
     } else {
       this.emitIdentifier(value);
@@ -78,8 +76,7 @@ var Emitter = class {
   }
   emitDelete(deleteOp) {
     const { cte, from, where, returning } = getData(deleteOp);
-    if (cte)
-      this.emitWith(cte);
+    if (cte) this.emitWith(cte);
     const table = getTable(from);
     sql.query({
       deleteFrom: sql.identifier(table.name),
@@ -89,8 +86,7 @@ var Emitter = class {
   }
   emitInsert(insert) {
     const { cte, into, values, select, onConflict, returning } = getData(insert);
-    if (cte)
-      this.emitWith(cte);
+    if (cte) this.emitWith(cte);
     const table = getTable(into);
     const tableName = sql.identifier(table.name);
     sql.query({
@@ -113,8 +109,7 @@ var Emitter = class {
     limit,
     offset
   }) {
-    if (cte)
-      this.emitWith(cte);
+    if (cte) this.emitWith(cte);
     const prefix = distinctOn ? sql`distinct on (${sql.join(distinctOn, sql`, `)})` : distinct && sql`distinct`;
     sql.query({
       select: sql.join([prefix, select]),
@@ -133,8 +128,7 @@ var Emitter = class {
   emitUpdate(update) {
     const { cte, table, set, where, returning } = getData(update);
     const tableApi = getTable(table);
-    if (cte)
-      this.emitWith(cte);
+    if (cte) this.emitWith(cte);
     sql.query({
       update: sql.identifier(tableApi.name),
       set,
@@ -158,8 +152,7 @@ var Emitter = class {
     const wrapQuery = Boolean(data.limit || data.offset || data.orderBy);
     const innerQuery = sql.chunk("emitSelect", data);
     const inner = wrapQuery ? sql`select * from (${innerQuery})` : innerQuery;
-    if (!data.select)
-      throw new Error("No selection defined");
+    if (!data.select) throw new Error("No selection defined");
     const fields = data.select.fieldNames();
     const subject = jsonArray(
       ...fields.map((name) => sql`_.${sql.identifier(name)}`)
@@ -168,8 +161,7 @@ var Emitter = class {
   }
   emitUniversal(runtimes) {
     const sql2 = runtimes[this.runtime] ?? runtimes.default;
-    if (!sql2)
-      throw new Error("Unsupported runtime");
+    if (!sql2) throw new Error("Unsupported runtime");
     sql2.emitTo(this);
   }
 };

package/dist/core/Query.js

@@ -17,8 +17,7 @@ var Executable = class {
   *[Symbol.iterator]() {
     const interim = this.#execute();
     const isAsync = interim instanceof Promise;
-    if (!isAsync)
-      return interim;
+    if (!isAsync) return interim;
     let result;
     yield interim.then((v) => result = v);
     return result;
@@ -27,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);
@@ -82,8 +85,7 @@ var Query = class extends Executable {
   }
   toSQL(db) {
     const resolver = db ? getResolver(db) : getData(this).resolver;
-    if (!resolver)
-      throw new Error("Query has no resolver");
+    if (!resolver) throw new Error("Query has no resolver");
     return resolver.toSQL(this);
   }
 };

package/dist/core/Resolver.js

@@ -51,8 +51,7 @@ var Batch = class {
     };
     for (let i = 0; i < this.#queries.length; i++) {
       const { mapRow } = this.#queries[i];
-      if (!mapRow)
-        continue;
+      if (!mapRow) continue;
       const rows = results[i];
       for (let j = 0; j < results[i].length; j++) {
         ctx.values = rows[i];
@@ -64,8 +63,7 @@ var Batch = class {
   };
   execute() {
     const results = this.#driver.batch(this.#queries);
-    if (results instanceof Promise)
-      return results.then(this.#transform);
+    if (results instanceof Promise) return results.then(this.#transform);
     return this.#transform(results);
   }
 };
@@ -81,8 +79,7 @@ var PreparedStatement = class {
     this.#specs = specs;
   }
   #transform = (rows) => {
-    if (!this.#mapRow)
-      return rows;
+    if (!this.#mapRow) return rows;
     const ctx = {
       values: void 0,
       index: 0,
@@ -97,14 +94,12 @@ var PreparedStatement = class {
   };
   all(inputs) {
     const rows = this.#stmt.values(this.#emitter.bind(inputs));
-    if (rows instanceof Promise)
-      return rows.then(this.#transform);
+    if (rows instanceof Promise) return rows.then(this.#transform);
     return this.#transform(rows);
   }
   get(inputs) {
     const rows = this.all(inputs);
-    if (rows instanceof Promise)
-      return rows.then((rows2) => rows2[0]);
+    if (rows instanceof Promise) return rows.then((rows2) => rows2[0]);
     return rows[0];
   }
   run(inputs) {

package/dist/core/Selection.js

@@ -15,8 +15,7 @@ var SqlColumn = class {
   }
   result(ctx) {
     const value = ctx.values[ctx.index++];
-    if (!this.sql.mapFromDriverValue)
-      return value;
+    if (!this.sql.mapFromDriverValue) return value;
     return this.sql.mapFromDriverValue(value, ctx.specs);
   }
 };
@@ -42,8 +41,7 @@ var ObjectColumn = class {
         }
       }
     }
-    if (isNullable)
-      return null;
+    if (isNullable) return null;
     return result;
   }
 };
@@ -60,8 +58,7 @@ var Selection = class {
   }
   #defineColumn(nullable, input) {
     const expr = getSql(input);
-    if (expr)
-      return new SqlColumn(expr, getField(input)?.targetName);
+    if (expr) return new SqlColumn(expr, getField(input)?.targetName);
     return new ObjectColumn(
       nullable,
       Object.entries(input).map(([name, value]) => [
@@ -77,10 +74,8 @@ var Selection = class {
     const expr = getSql(input);
     if (expr) {
       let exprName = name ?? expr.alias;
-      if (!exprName)
-        throw new Error("Missing field name");
-      while (names.has(exprName))
-        exprName = `${exprName}_`;
+      if (!exprName) throw new Error("Missing field name");
+      while (names.has(exprName)) exprName = `${exprName}_`;
       return [exprName];
     }
     return Object.entries(input).flatMap(
@@ -92,13 +87,11 @@ var Selection = class {
     if (expr) {
       let exprName = name ?? expr.alias;
       if (exprName) {
-        while (names.has(exprName))
-          exprName = `${exprName}_`;
+        while (names.has(exprName)) exprName = `${exprName}_`;
         names.add(exprName);
         if (hasField(input)) {
           const field = getField(input);
-          if (field.fieldName === exprName)
-            return expr;
+          if (field.fieldName === exprName) return expr;
         }
         return sql`${expr.forSelection()} as ${sql.identifier(exprName)}`;
       }

package/dist/core/Sql.js

@@ -29,8 +29,7 @@ var Sql = class _Sql {
     return this;
   }
   unsafe(sql2) {
-    if (sql2.length > 0)
-      this.chunk("emitUnsafe", sql2);
+    if (sql2.length > 0) this.chunk("emitUnsafe", sql2);
     return this;
   }
   field(field) {
@@ -38,8 +37,7 @@ var Sql = class _Sql {
   }
   add(sql2) {
     const inner = getSql(sql2);
-    if (!(inner instanceof _Sql))
-      throw new Error("Invalid SQL");
+    if (!(inner instanceof _Sql)) throw new Error("Invalid SQL");
     this.#chunks.push(...inner.#chunks);
     return this;
   }
@@ -47,19 +45,16 @@ var Sql = class _Sql {
     return this.chunk("emitValue", value);
   }
   getValue() {
-    if (this.#chunks.length !== 1)
-      return;
+    if (this.#chunks.length !== 1) return;
     const chunk = this.#chunks[0];
-    if (chunk?.type === "emitValue")
-      return chunk.inner;
+    if (chunk?.type === "emitValue") return chunk.inner;
   }
   inline(value) {
     return this.chunk("emitInline", value);
   }
   jsonPath(path) {
     const inner = path.target.#chunks[0];
-    if (inner?.type !== "emitJsonPath")
-      return this.chunk("emitJsonPath", path);
+    if (inner?.type !== "emitJsonPath") return this.chunk("emitJsonPath", path);
     const innerPath = inner.inner;
     return this.chunk("emitJsonPath", {
       ...innerPath,
@@ -83,8 +78,7 @@ var Sql = class _Sql {
   inlineValues() {
     return new _Sql(
       this.#chunks.map((chunk) => {
-        if (chunk.type !== "emitValue")
-          return chunk;
+        if (chunk.type !== "emitValue") return chunk;
         return new Chunk("emitInline", chunk.inner);
       })
     );
@@ -92,8 +86,7 @@ var Sql = class _Sql {
   inlineFields(withTableName) {
     return new _Sql(
       this.#chunks.flatMap((chunk) => {
-        if (chunk.type !== "emitField")
-          return [chunk];
+        if (chunk.type !== "emitField") return [chunk];
         const data = chunk.inner;
         if (withTableName)
           return [
@@ -109,8 +102,7 @@ var Sql = class _Sql {
     return sql.chunk("emitSelf", { name, inner: this });
   }
   emitTo(emitter) {
-    for (const chunk of this.#chunks)
-      emitter[chunk.type](chunk.inner);
+    for (const chunk of this.#chunks) emitter[chunk.type](chunk.inner);
   }
 };
 function sql(strings, ...inner) {
@@ -169,12 +161,9 @@ function sql(strings, ...inner) {
     return join(
       Object.entries(ast).map(([key, value2]) => {
         const statement = key.replace(/([A-Z])/g, " $1").toLocaleLowerCase();
-        if (value2 === true)
-          return sql2.unsafe(statement);
-        if (Array.isArray(value2))
-          value2 = join(value2);
-        if (!key)
-          return value2;
+        if (value2 === true) return sql2.unsafe(statement);
+        if (Array.isArray(value2)) value2 = join(value2);
+        if (!key) return value2;
         return value2 && sql2`${sql2.unsafe(statement)} ${value2}`;
       })
     );
@@ -184,8 +173,7 @@ function sql(strings, ...inner) {
     const parts = items.filter(Boolean);
     const sql3 = new Sql();
     for (let i = 0; i < parts.length; i++) {
-      if (i > 0)
-        sql3.add(separator);
+      if (i > 0) sql3.add(separator);
       sql3.add(parts[i]);
     }
     return sql3;

package/dist/core/Table.js

@@ -71,8 +71,7 @@ var TableApi = class extends TableData {
         const columnApi = getData(column);
         const { name: givenName } = columnApi;
         const field = new Field(this.aliased, givenName ?? name, columnApi);
-        if (columnApi.json)
-          return [name, jsonExpr(field)];
+        if (columnApi.json) return [name, jsonExpr(field)];
         return [name, field];
       })
     );
@@ -114,8 +113,7 @@ function table(name, columns, config, schemaName) {
     [internalTarget]: api.target(),
     ...api.fields()
   };
-  if (config)
-    api.config = config(table2);
+  if (config) api.config = config(table2);
   return table2;
 }
 function alias(table2, alias2) {

package/dist/core/Virtual.js

@@ -7,17 +7,14 @@ function virtual(alias, source) {
   if (source && hasSql(source)) {
     const expr = getSql(source);
     const name = expr.alias;
-    if (!name)
-      throw new Error("Cannot alias a virtual field without a name");
+    if (!name) throw new Error("Cannot alias a virtual field without a name");
     return Object.assign(new Field(alias, name, expr), target);
   }
   return new Proxy(target, {
     get(target2, field) {
-      if (field in target2)
-        return target2[field];
+      if (field in target2) return target2[field];
       const from = source?.[field];
-      if (typeof field !== "string")
-        return from;
+      if (typeof field !== "string") return from;
       return target2[field] = new Field(
         alias,
         field,

package/dist/core/expr/Conditions.js

@@ -23,18 +23,14 @@ var arrayContained = binop("<@");
 var arrayOverlaps = binop("&&");
 function and(...conditions) {
   const inputs = conditions.filter((v) => v !== void 0).map(input);
-  if (inputs.length === 0)
-    return bool(sql`true`);
-  if (inputs.length === 1)
-    return bool(inputs[0]);
+  if (inputs.length === 0) return bool(sql`true`);
+  if (inputs.length === 1) return bool(inputs[0]);
   return bool(sql`(${sql.join(inputs, sql` and `)})`);
 }
 function or(...conditions) {
   const inputs = conditions.filter((v) => v !== void 0).map(input);
-  if (inputs.length === 0)
-    return bool(sql`true`);
-  if (inputs.length === 1)
-    return bool(inputs[0]);
+  if (inputs.length === 0) return bool(sql`true`);
+  if (inputs.length === 1) return bool(inputs[0]);
   return bool(sql`(${sql.join(inputs, sql` or `)})`);
 }
 function not(condition) {
@@ -43,8 +39,7 @@ function not(condition) {
 function inArray(left, right) {
   const value = (hasSql(right) ? getSql(right).getValue() : void 0) ?? right;
   if (Array.isArray(value)) {
-    if (value.length === 0)
-      return sql`false`;
+    if (value.length === 0) return sql`false`;
     return bool(sql`${input(left)} in (${sql.join(value.map(input), sql`, `)})`);
   }
   return bool(sql`${input(left)} in ${input(right)}`);
@@ -52,8 +47,7 @@ function inArray(left, right) {
 function notInArray(left, right) {
   const value = (hasSql(right) ? getSql(right).getValue() : void 0) ?? right;
   if (Array.isArray(value)) {
-    if (value.length === 0)
-      return sql`true`;
+    if (value.length === 0) return sql`true`;
     return bool(
       sql`${input(left)} not in (${sql.join(value.map(input), sql`, `)})`
     );
@@ -94,8 +88,7 @@ function when(...cases) {
           const [condition, result] = pair;
           return sql`when ${input(condition)} then ${input(result)}`;
         }
-        if (index === cases.length - 1)
-          return sql`else ${input(pair)}`;
+        if (index === cases.length - 1) return sql`else ${input(pair)}`;
         throw new Error("Unexpected else condition");
       })
     ),

package/dist/core/expr/Include.js

@@ -13,10 +13,11 @@ 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 (!parsed)
-      return [];
+    if (first) {
+      const result = parsed ? select.mapRow({ values: parsed, index: 0, specs }) : null;
+      return result;
+    }
+    if (!parsed) return [];
     const rows = parsed;
     const ctx = {
       values: void 0,

package/dist/core/expr/Input.js

@@ -2,12 +2,9 @@
 import { getSql, getTable, hasSql, hasTable } from "../Internal.js";
 import { sql } from "../Sql.js";
 function input(value) {
-  if (typeof value !== "object" || value === null)
-    return sql.value(value);
-  if (hasTable(value))
-    return sql.identifier(getTable(value).name);
-  if (hasSql(value))
-    return getSql(value);
+  if (typeof value !== "object" || value === null) return sql.value(value);
+  if (hasTable(value)) return sql.identifier(getTable(value).name);
+  if (hasSql(value)) return getSql(value);
   return sql.value(value);
 }
 export {

package/dist/core/expr/Json.js

@@ -6,8 +6,7 @@ var INDEX_PROPERTY = /^\d+$/;
 function jsonExpr(e) {
   return new Proxy(e, {
     get(target, prop) {
-      if (typeof prop !== "string")
-        return Reflect.get(target, prop);
+      if (typeof prop !== "string") return Reflect.get(target, prop);
       const isNumber = INDEX_PROPERTY.test(prop);
       return jsonExpr(
         sql.jsonPath({
@@ -26,8 +25,9 @@ function jsonExpr(e) {
 function jsonAggregateArray(...args) {
   return callFunction(
     sql.universal({
+      // Once sqlite 3.45+ is more commonplace we can use jsonb_group_array
       sqlite: sql`json_group_array`,
-      postgres: sql`json_agg`,
+      postgres: sql`jsonb_agg`,
       mysql: sql`json_arrayagg`
     }),
     args
@@ -36,7 +36,7 @@ function jsonAggregateArray(...args) {
 function jsonArray(...args) {
   return callFunction(
     sql.universal({
-      postgres: sql`json_build_array`,
+      postgres: sql`jsonb_build_array`,
       default: sql`json_array`
     }),
     args

package/dist/core/query/Delete.js

@@ -16,8 +16,7 @@ var Delete = class extends Query {
   constructor(data) {
     super(data);
     this[internalData] = data;
-    if (data.returning)
-      this[internalSelection] = data.returning;
+    if (data.returning) this[internalSelection] = data.returning;
   }
   get [internalQuery]() {
     return sql.chunk("emitDelete", this);

package/dist/core/query/Insert.js

@@ -18,8 +18,7 @@ var Insert = class extends Query {
   constructor(data) {
     super(data);
     this[internalData] = data;
-    if (data.returning)
-      this[internalSelection] = data.returning;
+    if (data.returning) this[internalSelection] = data.returning;
   }
   get [internalQuery]() {
     return sql.chunk("emitInsert", this);
@@ -87,8 +86,7 @@ var InsertInto = class {
             const { $default, mapToDriverValue } = getData(column);
             if (value !== void 0)
               return input(mapToDriverValue?.(value) ?? value);
-            if ($default)
-              return $default();
+            if ($default) return $default();
             return defaultKeyword;
           }),
           sql`, `

package/dist/core/query/Select.js

@@ -102,8 +102,7 @@ var Select = class _Select extends UnionBase {
   }
   get [internalSelection]() {
     const { select } = getData(this);
-    if (!select)
-      throw new Error("No selection defined");
+    if (!select) throw new Error("No selection defined");
     return select;
   }
   get [internalQuery]() {

package/dist/core/query/Update.js

@@ -18,8 +18,7 @@ var Update = class extends Query {
   constructor(data) {
     super(data);
     this[internalData] = data;
-    if (data.returning)
-      this[internalSelection] = data.returning;
+    if (data.returning) this[internalSelection] = data.returning;
   }
   get [internalQuery]() {
     return sql.chunk("emitUpdate", this);

package/dist/driver/d1.d.ts

@@ -0,0 +1,25 @@
+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;
+    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,60 @@
+// 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) {
+      const results = await this.stmt.bind(...params).raw();
+      console.log(results);
+      return results;
+    }
+    await this.stmt.bind(...params).run();
+    return [];
+  }
+  free() {
+  }
+};
+var D1Driver = class {
+  constructor(client) {
+    this.client = client;
+  }
+  parsesJson = 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 results = [];
+    for (const { sql, params, isSelection } of queries)
+      results.push(await this.prepare(sql, { isSelection }).values(params));
+    return 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

@@ -4,6 +4,7 @@ import { AsyncDatabase, type TransactionOptions } from '../core/Database.js';
 import type { AsyncDriver, AsyncStatement, BatchQuery, PrepareOptions } from '../core/Driver.js';
 type Queryable = PromiseConnection | Pool | PoolConnection;
 declare class PreparedStatement implements AsyncStatement {
+    #private;
     private client;
     private sql;
     private name?;

package/dist/driver/mysql2.js

@@ -9,17 +9,25 @@ var PreparedStatement = class {
     this.sql = sql;
     this.name = name;
   }
+  #transformParam = (param) => {
+    if (param instanceof Uint8Array) return Buffer.from(param);
+    return param;
+  };
   all(params) {
-    return this.client.query(this.sql, params).then((res) => res[0]);
+    return this.client.query(this.sql, params.map(this.#transformParam)).then((res) => res[0]);
   }
   async run(params) {
-    await this.client.query(this.sql, params);
+    await this.client.query(this.sql, params.map(this.#transformParam));
   }
   get(params) {
     return this.all(params).then((rows) => rows[0] ?? null);
   }
   values(params) {
-    return this.client.query({ sql: this.sql, values: params, rowsAsArray: true }).then((res) => res[0]);
+    return this.client.query({
+      sql: this.sql,
+      values: params.map(this.#transformParam),
+      rowsAsArray: true
+    }).then((res) => res[0]);
   }
   free() {
   }
@@ -37,8 +45,7 @@ var Mysql2Driver = class _Mysql2Driver {
     return new PreparedStatement(this.client, sql, options?.name);
   }
   async close() {
-    if ("end" in this.client)
-      return this.client.end();
+    if ("end" in this.client) return this.client.end();
   }
   async batch(queries) {
     const transact = async (tx) => {
@@ -47,8 +54,7 @@ var Mysql2Driver = class _Mysql2Driver {
         results.push(await tx.prepare(sql).values(params));
       return results;
     };
-    if (this.depth > 0)
-      return transact(this);
+    if (this.depth > 0) return transact(this);
     return this.transaction(transact, {});
   }
   async transaction(run, options) {
@@ -60,8 +66,7 @@ var Mysql2Driver = class _Mysql2Driver {
       );
       if (this.depth === 0) {
         const setOptions = setTransaction(options);
-        if (setOptions)
-          await client.query(setOptions);
+        if (setOptions) await client.query(setOptions);
       }
       const result = await run(driver);
       await client.query(

package/dist/driver/pg.js

@@ -53,10 +53,8 @@ var PgDriver = class _PgDriver {
     return new PreparedStatement(this.client, sql, options?.name);
   }
   async close() {
-    if ("end" in this.client)
-      return this.client.end();
-    if ("release" in this.client)
-      return this.client.release();
+    if ("end" in this.client) return this.client.end();
+    if ("release" in this.client) return this.client.release();
   }
   async batch(queries) {
     return this.transaction(async (tx) => {
@@ -70,8 +68,7 @@ var PgDriver = class _PgDriver {
     const client = "totalCount" in this.client ? await this.client.connect() : this.client;
     try {
       await client.query(this.depth > 0 ? `savepoint d${this.depth}` : "begin");
-      if (this.depth === 0)
-        await client.query(setTransaction(options));
+      if (this.depth === 0) await client.query(setTransaction(options));
       const result = await run(new _PgDriver(client, this.depth + 1));
       await client.query(
         this.depth > 0 ? `release savepoint d${this.depth}` : "commit"
@@ -83,8 +80,7 @@ var PgDriver = class _PgDriver {
       );
       throw error;
     } finally {
-      if ("release" in client)
-        client.release();
+      if ("release" in client) client.release();
     }
   }
 };

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;

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";
@@ -54,8 +54,7 @@ var PGliteDriver = class _PGliteDriver {
         results.push(await tx.prepare(sql).values(params));
       return results;
     };
-    if (this.depth > 0)
-      return transact(this);
+    if (this.depth > 0) return transact(this);
     return this.transaction(transact, {});
   }
   async transaction(run, options) {

package/dist/driver/sql.js.js

@@ -10,14 +10,12 @@ var PreparedStatement = class {
   }
   *iterate(params) {
     this.stmt.bind(params);
-    while (this.stmt.step())
-      yield this.stmt.getAsObject();
+    while (this.stmt.step()) yield this.stmt.getAsObject();
     this.stmt.reset();
   }
   *iterateValues(params) {
     this.stmt.bind(params);
-    while (this.stmt.step())
-      yield this.stmt.get();
+    while (this.stmt.step()) yield this.stmt.get();
     this.stmt.reset();
   }
   all(params) {

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/columns.d.ts

@@ -1,4 +1,4 @@
-import { type Column, JsonColumn } from '../core/Column.js';
+import { JsonColumn, type Column } from '../core/Column.js';
 type Precision = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 export declare function bigint(name: string | undefined, options: {
     mode: 'number';
@@ -11,6 +11,7 @@ export declare function binary(name?: string, options?: {
     length?: number;
 }): Column<Uint8Array | null>;
 export declare function boolean(name?: string): Column<boolean | null>;
+export declare function blob(name?: string): Column<Uint8Array | null>;
 export declare function char(name?: string, options?: {
     length: number;
 }): Column<string | null>;

package/dist/mysql/columns.js

@@ -13,6 +13,9 @@ function binary(name, options) {
 function boolean(name) {
   return column({ name, type: column.boolean() });
 }
+function blob(name) {
+  return column({ name, type: column.blob() });
+}
 function char(name, options) {
   return column({ name, type: column.char(options?.length) });
 }
@@ -125,6 +128,7 @@ function year(name) {
 export {
   bigint,
   binary,
+  blob,
   boolean,
   char,
   date,

package/dist/mysql/dialect.js

@@ -24,8 +24,7 @@ var mysqlDialect = new Dialect(
       );
     }
     emitInline(value) {
-      if (value === null || value === void 0)
-        return this.sql += "null";
+      if (value === null || value === void 0) return this.sql += "null";
       if (typeof value === "number" || typeof value === "boolean")
         return this.sql += value;
       if (typeof value === "string")

package/dist/mysql/transactions.js

@@ -7,8 +7,7 @@ function startTransaction(options) {
   ].filter(Boolean).join(" ");
 }
 function setTransaction(options) {
-  if (!options.isolationLevel)
-    return;
+  if (!options.isolationLevel) return;
   return [
     "set transaction",
     options.isolationLevel && `isolation level ${options.isolationLevel}`

package/dist/postgres/columns.d.ts

@@ -1,4 +1,4 @@
-import { type Column, JsonColumn } from '../core/Column.js';
+import { JsonColumn, type Column } from '../core/Column.js';
 type Precision = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 type IntervalFields = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'year to month' | 'day to hour' | 'day to minute' | 'day to second' | 'hour to minute' | 'hour to second' | 'minute to second';
 export declare function bigint(name: string | undefined, options: {
@@ -30,7 +30,7 @@ export declare function interval(name?: string, options?: {
 }): Column<string | null>;
 export declare function serial(name?: string): Column<number>;
 export declare function boolean(name?: string): Column<boolean | null>;
-export declare function blob(name?: string): Column<Uint8Array | null>;
+export declare function bytea(name?: string): Column<Uint8Array | null>;
 export declare function text(name?: string): Column<string | null>;
 export declare function json<T>(name?: string): JsonColumn<T | null>;
 export declare function jsonb<T>(name?: string): JsonColumn<T | null>;

package/dist/postgres/columns.js

@@ -68,8 +68,8 @@ function serial(name) {
 function boolean(name) {
   return column({ name, type: column.boolean() });
 }
-function blob(name) {
-  return column({ name, type: column.blob() });
+function bytea(name) {
+  return column({ name, type: column.bytea() });
 }
 function text(name) {
   return column({ name, type: column.text() });
@@ -157,8 +157,8 @@ function varchar(name, options) {
 export {
   bigint,
   bigserial,
-  blob,
   boolean,
+  bytea,
   char,
   cidr,
   date,

package/dist/postgres/dialect.js

@@ -20,19 +20,14 @@ var postgresDialect = new Dialect(
       target.emitTo(this);
       for (let i = 0; i < segments.length; i++) {
         const access = segments[i];
-        if (i <= segments.length - 2)
-          this.sql += "->";
-        else if (i === segments.length - 1)
-          this.sql += asSql ? "->>" : "->";
-        if (typeof access === "number")
-          this.sql += access;
-        else
-          this.sql += this.quoteString(access);
+        if (i <= segments.length - 2) this.sql += "->";
+        else if (i === segments.length - 1) this.sql += asSql ? "->>" : "->";
+        if (typeof access === "number") this.sql += access;
+        else this.sql += this.quoteString(access);
       }
     }
     emitInline(value) {
-      if (value === null || value === void 0)
-        return this.sql += "null";
+      if (value === null || value === void 0) return this.sql += "null";
       if (typeof value === "number" || typeof value === "boolean")
         return this.sql += value;
       if (typeof value === "string")

package/dist/sqlite/dialect.js

@@ -26,14 +26,11 @@ var sqliteDialect = new Dialect(
       );
     }
     emitInline(value) {
-      if (value === null || value === void 0)
-        return this.sql += "null";
-      if (typeof value === "number")
-        return this.sql += value;
+      if (value === null || value === void 0) return this.sql += "null";
+      if (typeof value === "number") return this.sql += value;
       if (typeof value === "string")
         return this.sql += this.quoteString(value);
-      if (typeof value === "boolean")
-        return this.sql += value ? "1" : "0";
+      if (typeof value === "boolean") return this.sql += value ? "1" : "0";
       this.sql += `json(${this.quoteString(JSON.stringify(value))})`;
     }
     emitPlaceholder(name) {

package/dist/sqlite/diff.js

@@ -104,8 +104,7 @@ var sqliteDiff = (hasTable) => {
         sp.rollback(tableInfo);
       });
     } catch (err) {
-      if (!(err instanceof Rollback))
-        throw err;
+      if (!(err instanceof Rollback)) throw err;
       const localInstruction = err.data;
       const schemaInstruction = inline(tableApi.createTable());
       const stripStmt = (q) => q.slice("create table ".length);

package/dist/sqlite/functions.d.ts

@@ -5,8 +5,6 @@ import { type Input } from '../core/expr/Input.js';
 export declare const count: (x?: HasSql) => Sql<number>;
 /** The iif(X,Y,Z) function returns the value Y if X is true, and Z otherwise. The iif(X,Y,Z) function is logically equivalent to and generates the same bytecode as the CASE HasSql "CASE WHEN X THEN Y ELSE Z END".*/
 export declare const iif: <T>(x: Input<boolean>, y: Input<T>, z: Input<T>) => Sql<T>;
-/** Use the match operator for the FTS5 module */
-export declare const match: (table: HasTable, searchTerm: Input<string>) => Sql<boolean>;
 /** Returns a real value reflecting the accuracy of the current match */
 export declare const bm25: (table: HasTable, ...weights: Array<Input<number>>) => Sql<number>;
 /** The highlight() function returns a copy of the text from a specified column of the current row with extra markup text inserted to mark the start and end of phrase matches. */

package/dist/sqlite/functions.js

@@ -4,7 +4,6 @@ import { Functions } from "../core/expr/Functions.js";
 import { input } from "../core/expr/Input.js";
 var count = Functions.count;
 var iif = Functions.iif;
-var match = Functions.match;
 var bm25 = Functions.bm25;
 var highlight = Functions.highlight;
 var snippet = Functions.snippet;
@@ -118,7 +117,6 @@ export {
   log2,
   lower,
   ltrim,
-  match,
   max,
   min,
   mod,

package/dist/sqlite/transactions.js

@@ -3,8 +3,7 @@ var locks = /* @__PURE__ */ new WeakMap();
 function execTransaction(driver, depth, wrap, run, options) {
   const needsLock = options.async;
   const behavior = options.behavior ?? "deferred";
-  if (!needsLock)
-    return transact();
+  if (!needsLock) return transact();
   let trigger;
   const lock = new Promise((resolve) => trigger = resolve);
   const current = Promise.resolve(locks.get(driver));
@@ -14,8 +13,7 @@ function execTransaction(driver, depth, wrap, run, options) {
     try {
       driver.exec(depth > 0 ? `savepoint d${depth}` : `begin ${behavior}`);
       const result = run(wrap(depth + 1));
-      if (result instanceof Promise)
-        return result.then(release, rollback);
+      if (result instanceof Promise) return result.then(release, rollback);
       return release(result);
     } catch (error) {
       return rollback(error);

package/dist/universal/columns.d.ts

@@ -1,6 +1,12 @@
 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?: {
+    length: number;
+}): Column<string | null>;
 export declare function integer(name?: string): Column<number | null>;
+export declare function number(name?: string): Column<number | null>;
 export declare function boolean(name?: string): Column<boolean | null>;
 export declare function json<T>(name?: string): JsonColumn<T>;
+export declare function jsonb<T>(name?: string): JsonColumn<T>;
+export declare function blob(name?: string): Column<Uint8Array | null>;

package/dist/universal/columns.js

@@ -6,6 +6,18 @@ var idType = sql.universal({
   postgres: sql`integer generated always as identity`,
   mysql: sql`int not null auto_increment`
 });
+var blobType = sql.universal({
+  postgres: sql`bytea`,
+  default: sql`blob`
+});
+var numberType = sql.universal({
+  mysql: sql`double`,
+  default: sql`numeric`
+});
+var jsonbType = sql.universal({
+  mysql: sql`json`,
+  default: sql`jsonb`
+});
 function id(name) {
   return column({
     name,
@@ -16,18 +28,20 @@ function id(name) {
 function text(name) {
   return column({ name, type: column.text() });
 }
+function varchar(name, options) {
+  return column({ name, type: column.varchar(options?.length) });
+}
 function integer(name) {
   return column({ name, type: column.integer() });
 }
+function number(name) {
+  return column({ name, type: numberType, mapFromDriverValue: Number });
+}
 function boolean(name) {
   return column({
     name,
     type: column.boolean(),
-    mapFromDriverValue(value) {
-      if (typeof value === "number")
-        return value === 1;
-      return Boolean(value);
-    }
+    mapFromDriverValue: Boolean
   });
 }
 function json(name) {
@@ -42,10 +56,35 @@ function json(name) {
     }
   });
 }
+function jsonb(name) {
+  return new JsonColumn({
+    name,
+    type: jsonbType,
+    mapToDriverValue(value) {
+      return JSON.stringify(value);
+    },
+    mapFromDriverValue(value, { parsesJson }) {
+      return parsesJson ? value : JSON.parse(value);
+    }
+  });
+}
+function blob(name) {
+  return column({
+    name,
+    type: blobType,
+    mapFromDriverValue(value) {
+      return new Uint8Array(value);
+    }
+  });
+}
 export {
+  blob,
   boolean,
   id,
   integer,
   json,
-  text
+  jsonb,
+  number,
+  text,
+  varchar
 };

package/dist/universal/transactions.js

@@ -12,8 +12,7 @@ function txGenerator(create) {
       }
     };
     const handle = ({ done, value }) => {
-      if (done)
-        return value;
+      if (done) return value;
       return next(typeof value === "function" ? tx.transaction(value) : value);
     };
     return next();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "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,29 +26,29 @@
   },
   "files": ["dist"],
   "devDependencies": {
-    "@benmerckx/suite": "^0.3.0",
+    "@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.0.0",
-    "esbuild": "^0.18.11",
-    "glob": "^8.0.3",
+    "@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",
-    "mysql2": "^3.9.7",
-    "pg": "^8.11.5",
-    "rimraf": "^4.1.2",
-    "sade": "^1.8.1",
+    "mysql2": "^3.11.0",
+    "pg": "^8.12.0",
     "speedscope": "^1.15.0",
-    "sql.js": "^1.8.0",
-    "sqlite3": "^5.1.6",
-    "tsx": "^4.7.2",
-    "typescript": "^5.4.5",
-    "uvu": "^0.5.6"
+    "sql.js": "^1.11.0",
+    "sqlite3": "^5.1.7",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.2"
   }
 }