rado 1.0.6 → 1.0.7

package/dist/core/Database.d.ts

@@ -8,6 +8,7 @@ import { QueryBatch } from './Query.js';
 import { Resolver } from './Resolver.js';
 import type { Table } from './Table.js';
 export declare class Database<Meta extends QueryMeta = Either> extends Builder<Meta> implements HasResolver<Meta> {
+    #private;
     driver: Driver;
     dialect: Dialect;
     diff: Diff;
@@ -26,17 +27,20 @@ export declare class Database<Meta extends QueryMeta = Either> extends Builder<M
     transaction<T>(this: Database<Async>, run: (tx: Transaction<Meta>) => Promise<T>, options?: TransactionOptions[Meta['dialect']]): Promise<T>;
     transaction<T>(run: (tx: Transaction<Meta>) => T | Promise<T>, options?: TransactionOptions[Meta['dialect']]): Deliver<Meta, T>;
 }
+export interface TransactionUniversalOptions {
+    async?: boolean;
+}
 export interface TransactionOptions {
-    universal: never;
-    sqlite: {
+    universal: TransactionUniversalOptions;
+    sqlite: TransactionUniversalOptions & {
         behavior?: 'deferred' | 'immediate' | 'exclusive';
     };
-    postgres: {
+    postgres: TransactionUniversalOptions & {
         isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
         accessMode?: 'read only' | 'read write';
         deferrable?: boolean;
     };
-    mysql: {
+    mysql: TransactionUniversalOptions & {
         isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
         accessMode?: 'read only' | 'read write';
         withConsistentSnapshot?: boolean;

package/dist/core/Database.js

@@ -64,11 +64,15 @@ var Database = class extends Builder {
       throw new Error("Query has parameters");
     return this.driver.exec(emitter.sql);
   }
+  #transactionLock;
   transaction(run, options = {}) {
-    return this.driver.transaction((inner) => {
-      const tx = new Transaction(inner, this.dialect, this.diff);
-      return run(tx);
-    }, options);
+    return this.driver.transaction(
+      (inner) => {
+        const tx = new Transaction(inner, this.dialect, this.diff);
+        return run(tx);
+      },
+      { async: run.constructor.name === "AsyncFunction", ...options }
+    );
   }
 };
 var Rollback = class extends Error {

package/dist/core/Driver.d.ts

@@ -1,3 +1,4 @@
+import type { TransactionUniversalOptions } from './Database.js';
 export type Driver = SyncDriver | AsyncDriver;
 export type Statement = SyncStatement | AsyncStatement;
 export interface BatchQuery {
@@ -16,7 +17,7 @@ export interface SyncDriver extends DriverSpecs {
     close(): void;
     exec(query: string): void;
     prepare(query: string, options?: PrepareOptions): SyncStatement;
-    transaction<T>(run: (inner: SyncDriver) => T, options: unknown): T;
+    transaction<T>(run: (inner: SyncDriver) => T, options: TransactionUniversalOptions): T;
     batch(queries: Array<BatchQuery>): Array<Array<unknown>>;
 }
 export interface SyncStatement {
@@ -30,7 +31,7 @@ export interface AsyncDriver extends DriverSpecs {
     close(): Promise<void>;
     exec(query: string): Promise<void>;
     prepare(query: string, options?: PrepareOptions): AsyncStatement;
-    transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: unknown): Promise<T>;
+    transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionUniversalOptions): Promise<T>;
     batch(queries: Array<BatchQuery>): Promise<Array<Array<unknown>>>;
 }
 export interface AsyncStatement {

package/dist/driver/better-sqlite3.js

@@ -2,6 +2,7 @@
 import { SyncDatabase } from "../core/Database.js";
 import { sqliteDialect } from "../sqlite.js";
 import { sqliteDiff } from "../sqlite/diff.js";
+import { execTransaction } from "../sqlite/transactions.js";
 var PreparedStatement = class {
   constructor(stmt, isSelection) {
     this.stmt = stmt;
@@ -25,9 +26,10 @@ var PreparedStatement = class {
   free() {
   }
 };
-var BetterSqlite3Driver = class {
-  constructor(client) {
+var BetterSqlite3Driver = class _BetterSqlite3Driver {
+  constructor(client, depth = 0) {
     this.client = client;
+    this.depth = depth;
   }
   parsesJson = false;
   exec(query) {
@@ -48,11 +50,13 @@ var BetterSqlite3Driver = class {
     );
   }
   transaction(run, options) {
-    let result;
-    this.client.transaction(() => {
-      result = run(this);
-    })[options.behavior ?? "deferred"]();
-    return result;
+    return execTransaction(
+      this,
+      this.depth,
+      (depth) => new _BetterSqlite3Driver(this.client, depth),
+      run,
+      options
+    );
   }
 };
 function connect(db) {

package/dist/driver/bun-sqlite.js

@@ -2,6 +2,7 @@
 import { SyncDatabase } from "../core/Database.js";
 import { sqliteDialect } from "../sqlite.js";
 import { sqliteDiff } from "../sqlite/diff.js";
+import { execTransaction } from "../sqlite/transactions.js";
 var PreparedStatement = class {
   constructor(stmt) {
     this.stmt = stmt;
@@ -22,9 +23,10 @@ var PreparedStatement = class {
     this.stmt.finalize();
   }
 };
-var BunSqliteDriver = class {
-  constructor(client) {
+var BunSqliteDriver = class _BunSqliteDriver {
+  constructor(client, depth = 0) {
     this.client = client;
+    this.depth = depth;
   }
   parsesJson = false;
   exec(query) {
@@ -42,11 +44,13 @@ var BunSqliteDriver = class {
     }, {});
   }
   transaction(run, options) {
-    let result;
-    this.client.transaction(() => {
-      result = run(this);
-    })[options.behavior ?? "deferred"]();
-    return result;
+    return execTransaction(
+      this,
+      this.depth,
+      (depth) => new _BunSqliteDriver(this.client, depth),
+      run,
+      options
+    );
   }
 };
 function connect(db) {

package/dist/driver/sql.js.js

@@ -2,6 +2,7 @@
 import { SyncDatabase } from "../core/Database.js";
 import { sqliteDialect } from "../sqlite.js";
 import { sqliteDiff } from "../sqlite/diff.js";
+import { execTransaction } from "../sqlite/transactions.js";
 var PreparedStatement = class {
   constructor(client, stmt) {
     this.client = client;
@@ -59,16 +60,13 @@ var SqlJsDriver = class _SqlJsDriver {
     );
   }
   transaction(run, options) {
-    const behavior = options.behavior ?? "deferred";
-    this.exec(this.depth > 0 ? `savepoint d${this.depth}` : `begin ${behavior}`);
-    try {
-      const result = run(new _SqlJsDriver(this.client, this.depth + 1));
-      this.exec(this.depth > 0 ? `release d${this.depth}` : "commit");
-      return result;
-    } catch (error) {
-      this.exec(this.depth > 0 ? `rollback to d${this.depth}` : "rollback");
-      throw error;
-    }
+    return execTransaction(
+      this,
+      this.depth,
+      (depth) => new _SqlJsDriver(this.client, depth),
+      run,
+      options
+    );
   }
 };
 function connect(db) {

package/dist/sqlite/transactions.d.ts

@@ -0,0 +1,3 @@
+import type { TransactionOptions } from '../core/Database.js';
+import type { SyncDriver } from '../core/Driver.js';
+export declare function execTransaction<T>(driver: SyncDriver, depth: number, wrap: (depth: number) => SyncDriver, run: (inner: SyncDriver) => T, options: TransactionOptions['sqlite']): T;

package/dist/sqlite/transactions.js

@@ -0,0 +1,35 @@
+// src/sqlite/transactions.ts
+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();
+  let trigger;
+  const lock = new Promise((resolve) => trigger = resolve);
+  const current = Promise.resolve(locks.get(driver));
+  locks.set(driver, lock);
+  return current.then(transact).finally(trigger);
+  function transact() {
+    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);
+      return release(result);
+    } catch (error) {
+      return rollback(error);
+    }
+  }
+  function release(result) {
+    driver.exec(depth > 0 ? `release d${depth}` : "commit");
+    return result;
+  }
+  function rollback(error) {
+    driver.exec(depth > 0 ? `rollback to d${depth}` : "rollback");
+    throw error;
+  }
+}
+export {
+  execTransaction
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "license": "MIT",
   "type": "module",
   "scripts": {