rado 1.0.6 → 1.0.8

package/dist/core/Database.d.ts

@@ -26,17 +26,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

@@ -65,10 +65,13 @@ var Database = class extends Builder {
     return this.driver.exec(emitter.sql);
   }
   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/Emitter.d.ts

@@ -6,6 +6,7 @@ import { Sql } from './Sql.js';
 import type { TableApi } from './Table.js';
 import type { FieldData } from './expr/Field.js';
 import type { IncludeData } from './expr/Include.js';
+import { type JsonPath } from './expr/Json.js';
 import type { Delete } from './query/Delete.js';
 import type { Insert } from './query/Insert.js';
 import type { SelectData } from './query/Select.js';
@@ -21,7 +22,7 @@ export declare abstract class Emitter {
     abstract emitIdentifier(value: string): void;
     abstract emitValue(value: unknown): void;
     abstract emitInline(value: unknown): void;
-    abstract emitJsonPath(value: Array<number | string>): void;
+    abstract emitJsonPath(path: JsonPath): void;
     abstract emitPlaceholder(value: string): void;
     emitIdentifierOrSelf(value: string): void;
     selfName?: string;

package/dist/core/Selection.js

@@ -76,9 +76,11 @@ var Selection = class {
   #fieldNames(input, names, name) {
     const expr = getSql(input);
     if (expr) {
-      const exprName = name ?? expr.alias;
+      let exprName = name ?? expr.alias;
       if (!exprName)
         throw new Error("Missing field name");
+      while (names.has(exprName))
+        exprName = `${exprName}_`;
       return [exprName];
     }
     return Object.entries(input).flatMap(
@@ -98,7 +100,7 @@ var Selection = class {
           if (field.fieldName === exprName)
             return expr;
         }
-        return sql`${expr} as ${sql.identifier(exprName)}`;
+        return sql`${expr.forSelection()} as ${sql.identifier(exprName)}`;
       }
       return expr;
     }

package/dist/core/Sql.d.ts

@@ -3,6 +3,7 @@ import type { Emitter } from './Emitter.js';
 import { type HasSql, internalSql } from './Internal.js';
 import type { Runtime } from './MetaData.js';
 import type { FieldData } from './expr/Field.js';
+import type { JsonPath } from './expr/Json.js';
 type EmitMethods = {
     [K in keyof Emitter as K extends `emit${string}` ? K : never]: Emitter[K];
 };
@@ -31,7 +32,8 @@ export declare class Sql<Value = unknown> implements HasSql<Value> {
     value(value: unknown): Sql<Value>;
     getValue(): Value | undefined;
     inline(value: unknown): Sql<Value>;
-    jsonPath(path: Array<string | number>): Sql<Value>;
+    jsonPath(path: JsonPath): Sql<Value>;
+    forSelection(): Sql<Value>;
     placeholder(name: string): Sql<Value>;
     identifier(identifier: string): Sql<Value>;
     inlineValues(): Sql<Value>;
@@ -48,6 +50,7 @@ export declare namespace sql {
     export function placeholder<T>(name: string): Sql<T>;
     export function identifier<T>(identifier: string): Sql<T>;
     export function field<T>(field: FieldData): Sql<T>;
+    export function jsonPath<T>(path: JsonPath): Sql<T>;
     export function chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql;
     export function universal<T>(runtimes: Partial<Record<Runtime | 'default', Sql<T>>>): Sql<T>;
     type QueryChunk = HasSql | undefined;

package/dist/core/Sql.js

@@ -57,11 +57,21 @@ var Sql = class _Sql {
     return this.chunk("emitInline", value);
   }
   jsonPath(path) {
-    const last = this.#chunks.at(-1);
-    if (last?.type === "emitJsonPath")
-      last.inner.push(...path);
-    else
-      this.chunk("emitJsonPath", path);
+    const inner = path.target.#chunks[0];
+    if (inner?.type !== "emitJsonPath")
+      return this.chunk("emitJsonPath", path);
+    const innerPath = inner.inner;
+    return this.chunk("emitJsonPath", {
+      ...innerPath,
+      segments: [...innerPath.segments, ...path.segments]
+    });
+  }
+  forSelection() {
+    if (this.#chunks.length === 1) {
+      const first = this.#chunks[0];
+      if (first.type === "emitJsonPath")
+        return sql.jsonPath({ ...first.inner, asSql: false }).mapWith(this);
+    }
     return this;
   }
   placeholder(name) {
@@ -143,6 +153,10 @@ function sql(strings, ...inner) {
     return empty().field(field2);
   }
   sql2.field = field;
+  function jsonPath(path) {
+    return empty().jsonPath(path);
+  }
+  sql2.jsonPath = jsonPath;
   function chunk(type, inner) {
     return empty().chunk(type, inner);
   }

package/dist/core/expr/Json.d.ts

@@ -1,4 +1,5 @@
-import type { HasSql } from '../Internal.js';
+import { type HasSql } from '../Internal.js';
+import { type Sql } from '../Sql.js';
 import type { Input } from './Input.js';
 export interface JsonArrayHasSql<Value> extends HasSql<Array<Value>> {
     [index: number]: JsonExpr<Value>;
@@ -10,7 +11,12 @@ type NullableEach<T> = {
     [P in keyof T]: T[P] | null;
 };
 export type JsonExpr<Value> = [NonNullable<Value>] extends [Array<infer V>] ? JsonArrayHasSql<null extends Value ? V | null : V> : [NonNullable<Value>] extends [object] ? JsonRecordHasSql<null extends Value ? NullableEach<Value> : Value> : HasSql<Value>;
+export interface JsonPath {
+    target: Sql;
+    segments: Array<number | string>;
+    asSql: boolean;
+}
 export declare function jsonExpr<Value>(e: HasSql<Value>): JsonExpr<Value>;
-export declare function jsonAggregateArray(...args: Array<Input<unknown>>): import("../Sql.ts").Sql<unknown>;
-export declare function jsonArray(...args: Array<Input<unknown>>): import("../Sql.ts").Sql<unknown>;
+export declare function jsonAggregateArray(...args: Array<Input<unknown>>): Sql<unknown>;
+export declare function jsonArray(...args: Array<Input<unknown>>): Sql<unknown>;
 export {};

package/dist/core/expr/Json.js

@@ -1,4 +1,5 @@
 // src/core/expr/Json.ts
+import { getSql } from "../Internal.js";
 import { sql } from "../Sql.js";
 import { callFunction } from "./Functions.js";
 var INDEX_PROPERTY = /^\d+$/;
@@ -8,7 +9,17 @@ function jsonExpr(e) {
       if (typeof prop !== "string")
         return Reflect.get(target, prop);
       const isNumber = INDEX_PROPERTY.test(prop);
-      return jsonExpr(sql`${target}`.jsonPath([isNumber ? Number(prop) : prop]));
+      return jsonExpr(
+        sql.jsonPath({
+          target: getSql(target),
+          asSql: true,
+          segments: [isNumber ? Number(prop) : prop]
+        }).mapWith({
+          mapFromDriverValue(value, specs) {
+            return specs.parsesJson ? value : JSON.parse(value);
+          }
+        })
+      );
     }
   });
 }

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/mysql/dialect.js

@@ -16,10 +16,12 @@ var mysqlDialect = new Dialect(
       this.sql += "?";
       this.params.push(new ValueParam(value));
     }
-    emitJsonPath(path) {
-      this.sql += `->>${this.quoteString(
-        `$${path.map((p) => typeof p === "number" ? `[${p}]` : `.${p}`).join("")}`
-      )}`;
+    emitJsonPath({ target, asSql, segments }) {
+      target.emitTo(this);
+      this.sql += asSql ? "->>" : "->";
+      this.sql += this.quoteString(
+        `$${segments.map((p) => typeof p === "number" ? `[${p}]` : `.${p}`).join("")}`
+      );
     }
     emitInline(value) {
       if (value === null || value === void 0)

package/dist/postgres/dialect.js

@@ -16,13 +16,14 @@ var postgresDialect = new Dialect(
       this.sql += `$${++this.paramIndex}`;
       this.params.push(new ValueParam(value));
     }
-    emitJsonPath(path) {
-      for (let i = 0; i < path.length; i++) {
-        const access = path[i];
-        if (i <= path.length - 2)
+    emitJsonPath({ target, asSql, segments }) {
+      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 === path.length - 1)
-          this.sql += "->>";
+        else if (i === segments.length - 1)
+          this.sql += asSql ? "->>" : "->";
         if (typeof access === "number")
           this.sql += access;
         else

package/dist/sqlite/dialect.js

@@ -18,10 +18,12 @@ var sqliteDialect = new Dialect(
       this.sql += "?";
       this.params.push(new ValueParam(value));
     }
-    emitJsonPath(path) {
-      this.sql += `->>${this.quoteString(
-        `$${path.map((p) => typeof p === "number" ? `[${p}]` : `.${p}`).join("")}`
-      )}`;
+    emitJsonPath({ target, asSql, segments }) {
+      target.emitTo(this);
+      this.sql += asSql ? "->>" : "->";
+      this.sql += this.quoteString(
+        `$${segments.map((p) => typeof p === "number" ? `[${p}]` : `.${p}`).join("")}`
+      );
     }
     emitInline(value) {
       if (value === null || value === void 0)

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.8",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -27,7 +27,7 @@
   "files": ["dist"],
   "devDependencies": {
     "@benmerckx/suite": "^0.3.0",
-    "@biomejs/biome": "^1.6.1",
+    "@biomejs/biome": "^1.8.3",
     "@cloudflare/workers-types": "^4.20230628.0",
     "@electric-sql/pglite": "^0.1.5",
     "@sqlite.org/sqlite-wasm": "^3.42.0-build4",