rado 1.0.5 → 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/core/Query.d.ts

@@ -32,7 +32,7 @@ export declare abstract class Query<Result, Meta extends QueryMeta> extends Exec
     get(db?: HasResolver): Deliver<Meta, Result | null>;
     run(db?: HasResolver): Deliver<Meta, void>;
     prepare<Inputs extends Record<string, unknown>>(name?: string): PreparedQuery<Result, Inputs, Meta>;
-    toSQL(): {
+    toSQL(db?: HasResolver): {
         sql: string;
         params: Array<unknown>;
     };

package/dist/core/Query.js

@@ -80,8 +80,8 @@ var Query = class extends Executable {
   prepare(name) {
     return getData(this).resolver.prepare(this, name);
   }
-  toSQL() {
-    const { resolver } = getData(this);
+  toSQL(db) {
+    const resolver = db ? getResolver(db) : getData(this).resolver;
     if (!resolver)
       throw new Error("Query has no resolver");
     return resolver.toSQL(this);

package/dist/core/Sql.d.ts

@@ -29,6 +29,7 @@ export declare class Sql<Value = unknown> implements HasSql<Value> {
     field(field: FieldData): Sql<Value>;
     add(sql: HasSql): Sql<Value>;
     value(value: unknown): Sql<Value>;
+    getValue(): Value | undefined;
     inline(value: unknown): Sql<Value>;
     jsonPath(path: Array<string | number>): Sql<Value>;
     placeholder(name: string): Sql<Value>;
@@ -48,7 +49,7 @@ export declare namespace sql {
     export function identifier<T>(identifier: string): Sql<T>;
     export function field<T>(field: FieldData): Sql<T>;
     export function chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql;
-    export function universal(runtimes: Partial<Record<Runtime | 'default', Sql>>): Sql;
+    export function universal<T>(runtimes: Partial<Record<Runtime | 'default', Sql<T>>>): Sql<T>;
     type QueryChunk = HasSql | undefined;
     export function query(ast: Record<string, boolean | QueryChunk | Array<QueryChunk>>): Sql;
     export function join<T>(items: Array<Sql | HasSql | undefined | false>, separator?: Sql): Sql<T>;

package/dist/core/Sql.js

@@ -46,6 +46,13 @@ var Sql = class _Sql {
   value(value) {
     return this.chunk("emitValue", value);
   }
+  getValue() {
+    if (this.#chunks.length !== 1)
+      return;
+    const chunk = this.#chunks[0];
+    if (chunk?.type === "emitValue")
+      return chunk.inner;
+  }
   inline(value) {
     return this.chunk("emitInline", value);
   }
@@ -141,7 +148,7 @@ function sql(strings, ...inner) {
   }
   sql2.chunk = chunk;
   function universal(runtimes) {
-    return chunk("emitUniversal", runtimes);
+    return empty().chunk("emitUniversal", runtimes);
   }
   sql2.universal = universal;
   function query(ast) {

package/dist/core/expr/Conditions.js

@@ -1,5 +1,5 @@
 // src/core/expr/Conditions.ts
-import { getQuery } from "../Internal.js";
+import { getQuery, getSql, hasSql } from "../Internal.js";
 import { sql } from "../Sql.js";
 import { input } from "./Input.js";
 function bool(impl) {
@@ -41,19 +41,21 @@ function not(condition) {
   return bool(sql`not ${input(condition)}`);
 }
 function inArray(left, right) {
-  if (Array.isArray(right)) {
-    if (right.length === 0)
+  const value = (hasSql(right) ? getSql(right).getValue() : void 0) ?? right;
+  if (Array.isArray(value)) {
+    if (value.length === 0)
       return sql`false`;
-    return bool(sql`${input(left)} in (${sql.join(right.map(input), sql`, `)})`);
+    return bool(sql`${input(left)} in (${sql.join(value.map(input), sql`, `)})`);
   }
   return bool(sql`${input(left)} in ${input(right)}`);
 }
 function notInArray(left, right) {
-  if (Array.isArray(right)) {
-    if (right.length === 0)
+  const value = (hasSql(right) ? getSql(right).getValue() : void 0) ?? right;
+  if (Array.isArray(value)) {
+    if (value.length === 0)
       return sql`true`;
     return bool(
-      sql`${input(left)} not in (${sql.join(right.map(input), sql`, `)})`
+      sql`${input(left)} not in (${sql.join(value.map(input), sql`, `)})`
     );
   }
   return bool(sql`${input(left)} not in ${input(right)}`);

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

@@ -1,14 +1,10 @@
-import type { HasQuery, HasSql, HasTable } from '../core/Internal.js';
+import type { HasSql, HasTable } from '../core/Internal.js';
 import { type Sql } from '../core/Sql.js';
 import { type Input } from '../core/expr/Input.js';
 /**:  The count(X) function returns a count of the number of times that X is not NULL in a group. The count(*) function (with no arguments) returns the total number of rows in the group. */
 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>;
-/**
- * The EXISTS operator always evaluates to one of the integer values 0 and 1. If executing the SELECT statement specified as the right-hand operand of the EXISTS operator would return one or more rows, then the EXISTS operator evaluates to 1. If executing the SELECT would return no rows at all, then the EXISTS operator evaluates to 0.
- */
-export declare const exists: (cursor: HasQuery) => Sql<boolean>;
 /** 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 */

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 exists = Functions.exists;
 var match = Functions.match;
 var bm25 = Functions.bm25;
 var highlight = Functions.highlight;
@@ -101,7 +100,6 @@ export {
   date,
   datetime,
   degrees,
-  exists,
   exp,
   floor,
   group_concat,

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/dist/universal/functions.d.ts

@@ -1,4 +1,4 @@
 import { type Sql } from '../core/Sql.js';
-import type { Input } from '../core/expr/Input.js';
+import { type Input } from '../core/expr/Input.js';
 export declare function lastInsertId(): Sql<number>;
 export declare function concat(...slices: Array<Input<string | null>>): Sql<string>;

package/dist/universal/functions.js

@@ -1,16 +1,20 @@
 // src/universal/functions.ts
 import { sql } from "../core/Sql.js";
-import { callFunction } from "../core/expr/Functions.js";
+import { Functions } from "../core/expr/Functions.js";
+import { input } from "../core/expr/Input.js";
 var insertId = sql.universal({
-  sqlite: sql`last_insert_rowid()`,
-  postgres: sql`lastval()`,
-  mysql: sql`last_insert_id()`
+  sqlite: Functions.last_insert_rowid(),
+  postgres: Functions.lastval(),
+  mysql: Functions.last_insert_id()
 }).mapWith(Number);
 function lastInsertId() {
   return insertId;
 }
 function concat(...slices) {
-  return callFunction(sql`concat`, slices);
+  return sql.universal({
+    mysql: Functions.concat(...slices),
+    default: sql.join(slices.map(input), sql` || `)
+  });
 }
 export {
   concat,

package/package.json

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