rado 1.0.11 → 1.0.13

package/README.md

@@ -50,21 +50,22 @@ 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'`             |
+| 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'`             |
+| 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                 |
 
 | `MySQL                   ` | `import                      ` |
 | -------------------------- | ------------------------------ |
-| `mysql2`                   | `'rado/driver/mysql2'`         |
+| mysql2                     | rado/driver/mysql2             |
 
 Pass an instance of the database to the `connect` function to get started:
 

package/dist/core/Sql.d.ts

@@ -41,7 +41,7 @@ export declare class Sql<Value = unknown> implements HasSql<Value> {
     nameSelf(name: string): Sql;
     emitTo(emitter: Emitter): void;
 }
-export declare function sql<T>(strings: TemplateStringsArray, ...inner: Array<HasSql>): Sql<T>;
+export declare function sql<T>(strings: TemplateStringsArray, ...inner: Array<HasSql | unknown>): Sql<T>;
 export declare namespace sql {
     export function empty<T>(): Sql<T>;
     export function unsafe<T>(directSql: string | number): Sql<T>;

package/dist/core/Sql.js

@@ -1,5 +1,5 @@
 // src/core/Sql.ts
-import { getSql, internalSql } from "./Internal.js";
+import { getSql, hasSql, internalSql } from "./Internal.js";
 var Chunk = class {
   constructor(type, inner) {
     this.type = type;
@@ -111,7 +111,9 @@ function sql(strings, ...inner) {
     sql2.unsafe(strings[i]);
     if (i < inner.length) {
       const insert = inner[i];
-      sql2.add(insert);
+      if (insert !== null && typeof insert === "object" && hasSql(insert))
+        sql2.add(insert);
+      else sql2.value(insert);
     }
   }
   return sql2;

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.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "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 -A --unstable-ffi"
+    "test:deno": "deno test --node-modules-dir=false --no-check -A --unstable-ffi"
   },
   "sideEffects": false,
   "exports": {
@@ -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",