rado 1.0.9 → 1.0.10

package/README.md

@@ -150,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/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/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 [];
   }

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/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";

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/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.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,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"
   }
 }