bun-query-builder 0.1.34 → 0.1.36

package/dist/bin/cli.js

@@ -11973,6 +11973,43 @@ function createSQLiteSQL(filename) {
       return Promise.reject(error);
     }
   };
+  let txDepth = 0;
+  sqlFunction.begin = async (fnOrName, maybeFn) => {
+    const fn = typeof fnOrName === "function" ? fnOrName : maybeFn;
+    if (typeof fn !== "function")
+      throw new TypeError("[query-builder] sqlite begin(): a transaction callback is required");
+    const isSavepoint = txDepth > 0;
+    const spName = `qb_sp_${txDepth}`;
+    if (isSavepoint)
+      wrapper.run(`SAVEPOINT ${spName}`);
+    else
+      wrapper.run("BEGIN");
+    txDepth++;
+    try {
+      const result = await fn(sqlFunction);
+      txDepth--;
+      if (isSavepoint)
+        wrapper.run(`RELEASE SAVEPOINT ${spName}`);
+      else
+        wrapper.run("COMMIT");
+      return result;
+    } catch (err) {
+      txDepth--;
+      try {
+        if (isSavepoint) {
+          wrapper.run(`ROLLBACK TO SAVEPOINT ${spName}`);
+          wrapper.run(`RELEASE SAVEPOINT ${spName}`);
+        } else {
+          wrapper.run("ROLLBACK");
+        }
+      } catch {}
+      throw err;
+    }
+  };
+  sqlFunction.savepoint = sqlFunction.begin;
+  sqlFunction.beginDistributed = async () => {
+    throw new Error("[query-builder] beginDistributed() (two-phase commit) is not supported on SQLite. Use begin()/transaction().");
+  };
   sqlFunction._wrapper = wrapper;
   return sqlFunction;
 }
@@ -14999,7 +15036,7 @@ function createQueryBuilder(state) {
         return ensureBuilt().values();
       },
       toParams() {
-        return ensureBuilt().values?.() ?? [];
+        return [...whereParams];
       },
       __rawState() {
         return { sql: reorderSelectClauses(text), params: [...whereParams] };
@@ -15096,265 +15133,247 @@ function createQueryBuilder(state) {
           throw new Error(`[query-builder] selectFromSub(...).${methodName}() is not supported. ` + `Apply ${methodName}() to the underlying subquery BEFORE passing it to selectFromSub, ` + `or use the regular selectFrom(...) builder. This previously silently returned without ` + `affecting the SQL, producing wrong results \u2014 see stacksjs/stacks#1862 #11.`);
         };
       }
-      const sql = _sql;
-      const q = _sql`SELECT * FROM (${sub.toSQL()}) AS ${_sql(alias)}`;
-      const base = {
-        distinct() {
-          const rest = String(q).replace(/^SELECT\s+/i, "");
-          const newQ = sql`SELECT DISTINCT ${sql``}${sql(rest)}`;
-          return createSubQueryBuilder(newQ);
-        },
-        distinctOn(...columns) {
-          const match = /^SELECT\s+(\S+)\s+FROM/i.exec(String(q));
-          const body = match ? `${match[1]} FROM` : String(q);
-          const newQ = sql`SELECT DISTINCT ON (${sql(columns)}) ${sql``}${sql(body)}`;
-          return createSubQueryBuilder(newQ);
-        },
-        selectRaw(fragment) {
-          const newQ = sql`${q} , ${fragment}`;
-          return createSubQueryBuilder(newQ);
-        },
-        where(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "WHERE");
-          return createSubQueryBuilder(newQ);
-        },
-        andWhere(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "AND");
-          return createSubQueryBuilder(newQ);
-        },
-        orWhere(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "OR");
-          return createSubQueryBuilder(newQ);
-        },
-        orderBy(column, direction = "asc") {
-          const dir = direction === "asc" ? "ASC" : "DESC";
-          const current = String(q);
-          const newQ = SQL_PATTERNS.ORDER_BY.test(current) ? sql.unsafe(`${current}, ${column} ${dir}`) : sql`${q} ORDER BY ${sql(column)} ${direction === "asc" ? sql`ASC` : sql`DESC`}`;
-          return createSubQueryBuilder(newQ);
-        },
-        limit(n) {
-          const current = String(q);
-          const newQ = SQL_PATTERNS.LIMIT.test(current) ? sql.unsafe(current.replace(SQL_PATTERNS.LIMIT, ` LIMIT ${n}`)) : sql`${q} LIMIT ${n}`;
-          return createSubQueryBuilder(newQ);
-        },
-        offset(n) {
-          const current = String(q);
-          const newQ = SQL_PATTERNS.OFFSET.test(current) ? sql.unsafe(current.replace(SQL_PATTERNS.OFFSET, ` OFFSET ${n}`)) : sql`${q} OFFSET ${n}`;
-          return createSubQueryBuilder(newQ);
-        },
-        toSQL() {
-          return makeExecutableQuery(q);
-        },
-        async execute() {
-          return runWithHooks(q, "select");
-        },
-        async executeTakeFirst() {
-          const rows = await runWithHooks(q, "select");
-          return Array.isArray(rows) ? rows[0] : rows;
-        },
-        async executeTakeFirstOrThrow() {
-          const rows = await runWithHooks(q, "select");
-          const first = Array.isArray(rows) ? rows[0] : rows;
-          if (!first)
-            throw new Error("Record not found");
-          return first;
-        },
-        async get() {
-          return runWithHooks(q, "select");
-        },
-        async first() {
-          const rows = await runWithHooks(q, "select");
-          return Array.isArray(rows) ? rows[0] : rows;
-        },
-        async firstOrFail() {
-          const rows = await runWithHooks(q, "select");
-          const first = Array.isArray(rows) ? rows[0] : rows;
-          if (!first)
-            throw new Error("No rows found");
-          return first;
-        },
-        async exists() {
-          const countQ = sql`SELECT EXISTS(${q}) as exists`;
-          const result = await runWithHooks(countQ, "select");
-          return result?.[0]?.exists === true;
-        },
-        async doesntExist() {
-          const exists = await this.exists();
-          return !exists;
-        },
-        values() {
-          return q.values();
-        },
-        raw() {
-          return q.raw();
-        },
-        cancel() {
-          try {
-            q.cancel();
-          } catch {}
-        },
-        whereRaw: subqueryNotSupported("whereRaw"),
-        whereColumn: subqueryNotSupported("whereColumn"),
-        orWhereColumn: subqueryNotSupported("orWhereColumn"),
-        whereIn: subqueryNotSupported("whereIn"),
-        orWhereIn: subqueryNotSupported("orWhereIn"),
-        whereNotIn: subqueryNotSupported("whereNotIn"),
-        orWhereNotIn: subqueryNotSupported("orWhereNotIn"),
-        whereLike: subqueryNotSupported("whereLike"),
-        whereILike: subqueryNotSupported("whereILike"),
-        orWhereLike: subqueryNotSupported("orWhereLike"),
-        orWhereILike: subqueryNotSupported("orWhereILike"),
-        whereNotLike: subqueryNotSupported("whereNotLike"),
-        whereNotILike: subqueryNotSupported("whereNotILike"),
-        orWhereNotLike: subqueryNotSupported("orWhereNotLike"),
-        orWhereNotILike: subqueryNotSupported("orWhereNotILike"),
-        whereAny: subqueryNotSupported("whereAny"),
-        whereAll: subqueryNotSupported("whereAll"),
-        whereNone: subqueryNotSupported("whereNone"),
-        whereNested: subqueryNotSupported("whereNested"),
-        orWhereNested: subqueryNotSupported("orWhereNested"),
-        whereDate: subqueryNotSupported("whereDate"),
-        whereBetween: subqueryNotSupported("whereBetween"),
-        whereNotBetween: subqueryNotSupported("whereNotBetween"),
-        whereJsonContains: subqueryNotSupported("whereJsonContains"),
-        whereJsonPath: subqueryNotSupported("whereJsonPath"),
-        whereNull: subqueryNotSupported("whereNull"),
-        whereNotNull: subqueryNotSupported("whereNotNull"),
-        whereExists: subqueryNotSupported("whereExists"),
-        whereJsonDoesntContain: subqueryNotSupported("whereJsonDoesntContain"),
-        whereJsonContainsKey: subqueryNotSupported("whereJsonContainsKey"),
-        whereJsonDoesntContainKey: subqueryNotSupported("whereJsonDoesntContainKey"),
-        whereJsonLength: subqueryNotSupported("whereJsonLength"),
-        join: subqueryNotSupported("join"),
-        joinSub: subqueryNotSupported("joinSub"),
-        innerJoin: subqueryNotSupported("innerJoin"),
-        leftJoin: subqueryNotSupported("leftJoin"),
-        leftJoinSub: subqueryNotSupported("leftJoinSub"),
-        rightJoin: subqueryNotSupported("rightJoin"),
-        crossJoin: subqueryNotSupported("crossJoin"),
-        crossJoinSub: subqueryNotSupported("crossJoinSub"),
-        groupBy: subqueryNotSupported("groupBy"),
-        groupByRaw: subqueryNotSupported("groupByRaw"),
-        having: subqueryNotSupported("having"),
-        havingRaw: subqueryNotSupported("havingRaw"),
-        addSelect: subqueryNotSupported("addSelect"),
-        select: subqueryNotSupported("select"),
-        selectAll: subqueryNotSupported("selectAll"),
-        orderByDesc: subqueryNotSupported("orderByDesc"),
-        inRandomOrder: subqueryNotSupported("inRandomOrder"),
-        reorder: subqueryNotSupported("reorder"),
-        orderByRaw: subqueryNotSupported("orderByRaw"),
-        union: subqueryNotSupported("union"),
-        unionAll: subqueryNotSupported("unionAll"),
-        forPage: subqueryNotSupported("forPage"),
-        selectAllRelations: subqueryNotSupported("selectAllRelations"),
-        with: subqueryNotSupported("with"),
-        value: subqueryNotSupported("value"),
-        pluck: subqueryNotSupported("pluck"),
-        cursorPaginate: subqueryNotSupported("cursorPaginate"),
-        paginate: subqueryNotSupported("paginate"),
-        simplePaginate: subqueryNotSupported("simplePaginate"),
-        chunk: subqueryNotSupported("chunk"),
-        chunkById: subqueryNotSupported("chunkById"),
-        eachById: subqueryNotSupported("eachById"),
-        count: subqueryNotSupported("count"),
-        avg: subqueryNotSupported("avg"),
-        sum: subqueryNotSupported("sum"),
-        max: subqueryNotSupported("max"),
-        min: subqueryNotSupported("min"),
-        find: subqueryNotSupported("find"),
-        findOrFail: subqueryNotSupported("findOrFail"),
-        findMany: subqueryNotSupported("findMany"),
-        latest: subqueryNotSupported("latest"),
-        oldest: subqueryNotSupported("oldest"),
-        lazy: subqueryNotSupported("lazy"),
-        lazyById: subqueryNotSupported("lazyById"),
-        pipe: (fn) => fn(this),
-        when: subqueryNotSupported("when"),
-        tap: () => this,
-        dump: () => this,
-        dd: () => {
-          throw new Error("Dump and Die");
-        },
-        explain: () => Promise.resolve([]),
-        simple: () => q.simple(),
-        toText: () => String(q),
-        toParams: () => q.values?.() ?? [],
-        withTimeout: () => this,
-        abort: () => this,
-        lockForUpdate: () => this,
-        sharedLock: () => this,
-        withCTE: () => this,
-        withRecursive: () => this,
-        cache: () => this,
-        clone: () => this,
-        withTrashed: () => this,
-        onlyTrashed: () => this,
-        scope: () => this,
-        get rows() {
-          return [];
-        },
-        get row() {
-          return;
-        }
+      validateIdentifier(String(alias), "selectFromSub(alias)");
+      const rawState = typeof sub.__rawState === "function" ? sub.__rawState() : null;
+      const subExec = sub.toSQL();
+      const subText = rawState?.sql ?? (typeof subExec === "string" ? subExec : subExec?.sql ?? String(subExec));
+      const subParams = rawState?.params ?? (Array.isArray(subExec?.values) ? subExec.values : []);
+      const baseText = `SELECT * FROM (${subText}) AS ${String(alias)}`;
+      const appendWhere = (text, params, hasWhere, expr, op, value, connector) => {
+        const kw = !hasWhere ? "WHERE" : connector === "WHERE" ? "AND" : connector;
+        const out = [...params];
+        const cmp = (col, operator, val) => {
+          validateIdentifier(col, "selectFromSub where(column)");
+          const o = assertSafeWhereOperator(operator, "selectFromSub where(operator)");
+          if (o === "in" || o === "not in") {
+            const vals = Array.isArray(val) ? val : [val];
+            const phs = getPlaceholders(vals.length, out.length + 1);
+            out.push(...vals);
+            return `${col} ${o.toUpperCase()} (${phs})`;
+          }
+          const ph = getPlaceholder(out.length + 1);
+          out.push(val);
+          return `${col} ${o} ${ph}`;
+        };
+        let clause;
+        if (typeof expr === "string" && op !== undefined)
+          clause = cmp(expr, op, value);
+        else if (Array.isArray(expr) && expr.length === 3)
+          clause = cmp(expr[0], expr[1], expr[2]);
+        else if (expr && typeof expr === "object")
+          clause = Object.entries(expr).map(([k, v]) => cmp(k, "=", v)).join(" AND ");
+        else
+          return { text, params };
+        return { text: `${text} ${kw} ${clause}`, params: out };
       };
-      function createSubQueryBuilder(newQ) {
-        return {
-          ...base,
-          toSQL: () => makeExecutableQuery(newQ),
-          execute: () => runWithHooks(newQ, "select"),
-          get: () => runWithHooks(newQ, "select"),
-          first: async () => {
-            const rows = await runWithHooks(newQ, "select");
+      function makeSub(text, params, hasWhere = false) {
+        const build = () => params.length > 0 ? _sql.unsafe(text, params) : _sql.unsafe(text);
+        const base = {
+          distinct() {
+            return makeSub(text.replace(/^SELECT\s+/i, "SELECT DISTINCT "), params, hasWhere);
+          },
+          distinctOn(...columns) {
+            const cols = columns.map(String).join(", ");
+            return makeSub(text.replace(/^SELECT\s+/i, `SELECT DISTINCT ON (${cols}) `), params, hasWhere);
+          },
+          selectRaw(fragment) {
+            const frag = renderRawFragment(fragment, "selectFromSub.selectRaw(fragment)");
+            const fromIdx = text.indexOf(" FROM ");
+            const newText = fromIdx !== -1 ? `${text.slice(0, fromIdx)}, ${frag}${text.slice(fromIdx)}` : `${text}, ${frag}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          where(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "WHERE");
+            return makeSub(r.text, r.params, true);
+          },
+          andWhere(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "AND");
+            return makeSub(r.text, r.params, true);
+          },
+          orWhere(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "OR");
+            return makeSub(r.text, r.params, true);
+          },
+          orderBy(column, direction = "asc") {
+            validateIdentifier(String(column), "selectFromSub.orderBy(column)");
+            const dir = direction === "asc" ? "ASC" : "DESC";
+            const newText = SQL_PATTERNS.ORDER_BY.test(text) ? `${text}, ${column} ${dir}` : `${text} ORDER BY ${column} ${dir}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          limit(n) {
+            if (!Number.isInteger(n) || n < 0)
+              throw new TypeError(`[query-builder] selectFromSub.limit(n): expected non-negative integer, got ${n}`);
+            const newText = SQL_PATTERNS.LIMIT.test(text) ? text.replace(SQL_PATTERNS.LIMIT, ` LIMIT ${n}`) : `${text} LIMIT ${n}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          offset(n) {
+            if (!Number.isInteger(n) || n < 0)
+              throw new TypeError(`[query-builder] selectFromSub.offset(n): expected non-negative integer, got ${n}`);
+            const newText = SQL_PATTERNS.OFFSET.test(text) ? text.replace(SQL_PATTERNS.OFFSET, ` OFFSET ${n}`) : `${text} OFFSET ${n}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          toSQL() {
+            return makeExecutableQuery(build(), text);
+          },
+          async execute() {
+            return runWithHooks(build(), "select");
+          },
+          async executeTakeFirst() {
+            const rows = await runWithHooks(build(), "select");
             return Array.isArray(rows) ? rows[0] : rows;
           },
-          firstOrFail: async () => {
-            const rows = await runWithHooks(newQ, "select");
+          async executeTakeFirstOrThrow() {
+            const rows = await runWithHooks(build(), "select");
+            const first = Array.isArray(rows) ? rows[0] : rows;
+            if (!first)
+              throw new Error("Record not found");
+            return first;
+          },
+          async get() {
+            return runWithHooks(build(), "select");
+          },
+          async first() {
+            const rows = await runWithHooks(build(), "select");
+            return Array.isArray(rows) ? rows[0] : rows;
+          },
+          async firstOrFail() {
+            const rows = await runWithHooks(build(), "select");
             const first = Array.isArray(rows) ? rows[0] : rows;
             if (!first)
               throw new Error("No rows found");
             return first;
           },
-          exists: async () => {
-            const countQ = sql`SELECT EXISTS(${newQ}) as exists`;
-            const result = await runWithHooks(countQ, "select");
-            return result?.[0]?.exists === true;
+          async count() {
+            const q = params.length > 0 ? _sql.unsafe(`SELECT COUNT(*) as c FROM (${text}) as sub`, params) : _sql.unsafe(`SELECT COUNT(*) as c FROM (${text}) as sub`);
+            const rows = await runWithHooks(q, "select");
+            return Number(rows?.[0]?.c ?? 0);
+          },
+          async exists() {
+            const q = params.length > 0 ? _sql.unsafe(`SELECT EXISTS(${text}) as e`, params) : _sql.unsafe(`SELECT EXISTS(${text}) as e`);
+            const result = await runWithHooks(q, "select");
+            return Boolean(result?.[0]?.e);
+          },
+          async doesntExist() {
+            return !await base.exists();
+          },
+          values() {
+            return build().values();
           },
-          doesntExist: async () => {
-            const exists = await base.exists();
-            return !exists;
+          raw() {
+            return build().raw();
           },
-          values: () => newQ.values(),
-          raw: () => newQ.raw(),
-          cancel: () => {
+          cancel() {
             try {
-              newQ.cancel();
+              build().cancel();
             } catch {}
           },
-          simple: () => newQ.simple(),
-          toText: () => String(newQ),
-          toParams: () => newQ.values?.() ?? []
+          whereRaw: subqueryNotSupported("whereRaw"),
+          whereColumn: subqueryNotSupported("whereColumn"),
+          orWhereColumn: subqueryNotSupported("orWhereColumn"),
+          whereIn: subqueryNotSupported("whereIn"),
+          orWhereIn: subqueryNotSupported("orWhereIn"),
+          whereNotIn: subqueryNotSupported("whereNotIn"),
+          orWhereNotIn: subqueryNotSupported("orWhereNotIn"),
+          whereLike: subqueryNotSupported("whereLike"),
+          whereILike: subqueryNotSupported("whereILike"),
+          orWhereLike: subqueryNotSupported("orWhereLike"),
+          orWhereILike: subqueryNotSupported("orWhereILike"),
+          whereNotLike: subqueryNotSupported("whereNotLike"),
+          whereNotILike: subqueryNotSupported("whereNotILike"),
+          orWhereNotLike: subqueryNotSupported("orWhereNotLike"),
+          orWhereNotILike: subqueryNotSupported("orWhereNotILike"),
+          whereAny: subqueryNotSupported("whereAny"),
+          whereAll: subqueryNotSupported("whereAll"),
+          whereNone: subqueryNotSupported("whereNone"),
+          whereNested: subqueryNotSupported("whereNested"),
+          orWhereNested: subqueryNotSupported("orWhereNested"),
+          whereDate: subqueryNotSupported("whereDate"),
+          whereBetween: subqueryNotSupported("whereBetween"),
+          whereNotBetween: subqueryNotSupported("whereNotBetween"),
+          whereJsonContains: subqueryNotSupported("whereJsonContains"),
+          whereJsonPath: subqueryNotSupported("whereJsonPath"),
+          whereNull: subqueryNotSupported("whereNull"),
+          whereNotNull: subqueryNotSupported("whereNotNull"),
+          whereExists: subqueryNotSupported("whereExists"),
+          whereJsonDoesntContain: subqueryNotSupported("whereJsonDoesntContain"),
+          whereJsonContainsKey: subqueryNotSupported("whereJsonContainsKey"),
+          whereJsonDoesntContainKey: subqueryNotSupported("whereJsonDoesntContainKey"),
+          whereJsonLength: subqueryNotSupported("whereJsonLength"),
+          join: subqueryNotSupported("join"),
+          joinSub: subqueryNotSupported("joinSub"),
+          innerJoin: subqueryNotSupported("innerJoin"),
+          leftJoin: subqueryNotSupported("leftJoin"),
+          leftJoinSub: subqueryNotSupported("leftJoinSub"),
+          rightJoin: subqueryNotSupported("rightJoin"),
+          crossJoin: subqueryNotSupported("crossJoin"),
+          crossJoinSub: subqueryNotSupported("crossJoinSub"),
+          groupBy: subqueryNotSupported("groupBy"),
+          groupByRaw: subqueryNotSupported("groupByRaw"),
+          having: subqueryNotSupported("having"),
+          havingRaw: subqueryNotSupported("havingRaw"),
+          addSelect: subqueryNotSupported("addSelect"),
+          select: subqueryNotSupported("select"),
+          selectAll: subqueryNotSupported("selectAll"),
+          orderByDesc: subqueryNotSupported("orderByDesc"),
+          inRandomOrder: subqueryNotSupported("inRandomOrder"),
+          reorder: subqueryNotSupported("reorder"),
+          orderByRaw: subqueryNotSupported("orderByRaw"),
+          union: subqueryNotSupported("union"),
+          unionAll: subqueryNotSupported("unionAll"),
+          forPage: subqueryNotSupported("forPage"),
+          selectAllRelations: subqueryNotSupported("selectAllRelations"),
+          with: subqueryNotSupported("with"),
+          value: subqueryNotSupported("value"),
+          pluck: subqueryNotSupported("pluck"),
+          cursorPaginate: subqueryNotSupported("cursorPaginate"),
+          paginate: subqueryNotSupported("paginate"),
+          simplePaginate: subqueryNotSupported("simplePaginate"),
+          chunk: subqueryNotSupported("chunk"),
+          chunkById: subqueryNotSupported("chunkById"),
+          eachById: subqueryNotSupported("eachById"),
+          avg: subqueryNotSupported("avg"),
+          sum: subqueryNotSupported("sum"),
+          max: subqueryNotSupported("max"),
+          min: subqueryNotSupported("min"),
+          find: subqueryNotSupported("find"),
+          findOrFail: subqueryNotSupported("findOrFail"),
+          findMany: subqueryNotSupported("findMany"),
+          latest: subqueryNotSupported("latest"),
+          oldest: subqueryNotSupported("oldest"),
+          lazy: subqueryNotSupported("lazy"),
+          lazyById: subqueryNotSupported("lazyById"),
+          pipe: (fn) => fn(base),
+          when: subqueryNotSupported("when"),
+          tap: () => base,
+          dump: () => base,
+          dd: () => {
+            throw new Error("Dump and Die");
+          },
+          explain: () => Promise.resolve([]),
+          simple: () => build().simple(),
+          toText: () => text,
+          toParams: () => [...params],
+          withTimeout: () => base,
+          abort: () => base,
+          lockForUpdate: () => base,
+          sharedLock: () => base,
+          withCTE: () => base,
+          withRecursive: () => base,
+          cache: () => base,
+          clone: () => base,
+          withTrashed: () => base,
+          onlyTrashed: () => base,
+          scope: () => base,
+          get rows() {
+            return [];
+          },
+          get row() {
+            return;
+          }
         };
+        return base;
       }
-      function applyWhereCondition(query, expr, op, value, prefix = "WHERE") {
-        if (typeof expr === "string" && op !== undefined) {
-          const clause = Array.isArray(value) ? `${expr} IN (?)` : `${expr} ${op} ?`;
-          return sql`${query} ${sql(prefix)} ${sql(clause)}`;
-        } else if (Array.isArray(expr) && expr.length === 3) {
-          const [column, operator, val] = expr;
-          const clause = Array.isArray(val) ? `${column} IN (?)` : `${column} ${operator} ?`;
-          return sql`${query} ${sql(prefix)} ${sql(clause)}`;
-        } else if (typeof expr === "object" && expr !== null) {
-          const conditions = Object.entries(expr).map(([key, val]) => {
-            const clause = Array.isArray(val) ? `${key} IN (?)` : `${key} = ?`;
-            return sql`${sql(clause)}`;
-          });
-          const combined = conditions.reduce((acc, cond, i) => i === 0 ? cond : sql`${acc} AND ${cond}`);
-          return sql`${query} ${sql(prefix)} ${combined}`;
-        }
-        return query;
-      }
-      return base;
+      return makeSub(baseText, subParams);
     },
     insertInto(table) {
       let built;
@@ -15892,12 +15911,15 @@ function createQueryBuilder(state) {
     async transaction(fn, options) {
       const defaults = state?.txDefaults;
       const opts = { ...defaults, ...options };
+      const txConn = state?.sql ?? bunSql;
+      const nested = state?.inTransaction === true;
+      const txMethod = nested && typeof txConn?.savepoint === "function" ? "savepoint" : "begin";
       const runWith = async (attempt2) => {
         opts.logger?.({ type: "start", attempt: attempt2 });
         const start = Date.now();
-        return await bunSql.begin(async (tx) => {
-          const qb = createQueryBuilder({ sql: tx, meta, schema });
-          if (opts?.isolation) {
+        return await txConn[txMethod](async (tx) => {
+          const qb = createQueryBuilder({ sql: tx, meta, schema, inTransaction: true });
+          if (opts?.isolation && !nested) {
             const level = opts.isolation;
             const upper = level === "read committed" ? "READ COMMITTED" : level === "repeatable read" ? "REPEATABLE READ" : "SERIALIZABLE";
             if (config5.dialect === "postgres") {
@@ -15962,7 +15984,8 @@ function createQueryBuilder(state) {
       });
     },
     async beginDistributed(name, fn) {
-      const res = await bunSql.beginDistributed(name, async (tx) => {
+      const txConn = state?.sql ?? bunSql;
+      const res = await txConn.beginDistributed(name, async (tx) => {
         const qb = createQueryBuilder({ sql: tx, meta, schema });
         return await fn(qb);
       });
@@ -30112,7 +30135,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.34";
+var version2 = "0.1.36";
 
 // bin/cli.ts
 init_actions();

package/dist/client.d.ts

@@ -386,6 +386,7 @@ declare interface InternalState {
   meta?: SchemaMeta
   schema?: any
   txDefaults?: TransactionOptions
+  inTransaction?: boolean
 }
 declare interface TxBackoff { baseMs?: number, maxMs?: number, factor?: number, jitter?: boolean }
 declare interface TxLoggerEvent { type: 'start' | 'retry' | 'commit' | 'rollback' | 'error', attempt: number, error?: any, durationMs?: number }

package/dist/src/index.js

@@ -11973,6 +11973,43 @@ function createSQLiteSQL(filename) {
       return Promise.reject(error);
     }
   };
+  let txDepth = 0;
+  sqlFunction.begin = async (fnOrName, maybeFn) => {
+    const fn = typeof fnOrName === "function" ? fnOrName : maybeFn;
+    if (typeof fn !== "function")
+      throw new TypeError("[query-builder] sqlite begin(): a transaction callback is required");
+    const isSavepoint = txDepth > 0;
+    const spName = `qb_sp_${txDepth}`;
+    if (isSavepoint)
+      wrapper.run(`SAVEPOINT ${spName}`);
+    else
+      wrapper.run("BEGIN");
+    txDepth++;
+    try {
+      const result = await fn(sqlFunction);
+      txDepth--;
+      if (isSavepoint)
+        wrapper.run(`RELEASE SAVEPOINT ${spName}`);
+      else
+        wrapper.run("COMMIT");
+      return result;
+    } catch (err) {
+      txDepth--;
+      try {
+        if (isSavepoint) {
+          wrapper.run(`ROLLBACK TO SAVEPOINT ${spName}`);
+          wrapper.run(`RELEASE SAVEPOINT ${spName}`);
+        } else {
+          wrapper.run("ROLLBACK");
+        }
+      } catch {}
+      throw err;
+    }
+  };
+  sqlFunction.savepoint = sqlFunction.begin;
+  sqlFunction.beginDistributed = async () => {
+    throw new Error("[query-builder] beginDistributed() (two-phase commit) is not supported on SQLite. Use begin()/transaction().");
+  };
   sqlFunction._wrapper = wrapper;
   return sqlFunction;
 }
@@ -14999,7 +15036,7 @@ function createQueryBuilder(state) {
         return ensureBuilt().values();
       },
       toParams() {
-        return ensureBuilt().values?.() ?? [];
+        return [...whereParams];
       },
       __rawState() {
         return { sql: reorderSelectClauses(text), params: [...whereParams] };
@@ -15096,265 +15133,247 @@ function createQueryBuilder(state) {
           throw new Error(`[query-builder] selectFromSub(...).${methodName}() is not supported. ` + `Apply ${methodName}() to the underlying subquery BEFORE passing it to selectFromSub, ` + `or use the regular selectFrom(...) builder. This previously silently returned without ` + `affecting the SQL, producing wrong results \u2014 see stacksjs/stacks#1862 #11.`);
         };
       }
-      const sql = _sql;
-      const q = _sql`SELECT * FROM (${sub.toSQL()}) AS ${_sql(alias)}`;
-      const base = {
-        distinct() {
-          const rest = String(q).replace(/^SELECT\s+/i, "");
-          const newQ = sql`SELECT DISTINCT ${sql``}${sql(rest)}`;
-          return createSubQueryBuilder(newQ);
-        },
-        distinctOn(...columns) {
-          const match = /^SELECT\s+(\S+)\s+FROM/i.exec(String(q));
-          const body = match ? `${match[1]} FROM` : String(q);
-          const newQ = sql`SELECT DISTINCT ON (${sql(columns)}) ${sql``}${sql(body)}`;
-          return createSubQueryBuilder(newQ);
-        },
-        selectRaw(fragment) {
-          const newQ = sql`${q} , ${fragment}`;
-          return createSubQueryBuilder(newQ);
-        },
-        where(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "WHERE");
-          return createSubQueryBuilder(newQ);
-        },
-        andWhere(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "AND");
-          return createSubQueryBuilder(newQ);
-        },
-        orWhere(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "OR");
-          return createSubQueryBuilder(newQ);
-        },
-        orderBy(column, direction = "asc") {
-          const dir = direction === "asc" ? "ASC" : "DESC";
-          const current = String(q);
-          const newQ = SQL_PATTERNS.ORDER_BY.test(current) ? sql.unsafe(`${current}, ${column} ${dir}`) : sql`${q} ORDER BY ${sql(column)} ${direction === "asc" ? sql`ASC` : sql`DESC`}`;
-          return createSubQueryBuilder(newQ);
-        },
-        limit(n) {
-          const current = String(q);
-          const newQ = SQL_PATTERNS.LIMIT.test(current) ? sql.unsafe(current.replace(SQL_PATTERNS.LIMIT, ` LIMIT ${n}`)) : sql`${q} LIMIT ${n}`;
-          return createSubQueryBuilder(newQ);
-        },
-        offset(n) {
-          const current = String(q);
-          const newQ = SQL_PATTERNS.OFFSET.test(current) ? sql.unsafe(current.replace(SQL_PATTERNS.OFFSET, ` OFFSET ${n}`)) : sql`${q} OFFSET ${n}`;
-          return createSubQueryBuilder(newQ);
-        },
-        toSQL() {
-          return makeExecutableQuery(q);
-        },
-        async execute() {
-          return runWithHooks(q, "select");
-        },
-        async executeTakeFirst() {
-          const rows = await runWithHooks(q, "select");
-          return Array.isArray(rows) ? rows[0] : rows;
-        },
-        async executeTakeFirstOrThrow() {
-          const rows = await runWithHooks(q, "select");
-          const first = Array.isArray(rows) ? rows[0] : rows;
-          if (!first)
-            throw new Error("Record not found");
-          return first;
-        },
-        async get() {
-          return runWithHooks(q, "select");
-        },
-        async first() {
-          const rows = await runWithHooks(q, "select");
-          return Array.isArray(rows) ? rows[0] : rows;
-        },
-        async firstOrFail() {
-          const rows = await runWithHooks(q, "select");
-          const first = Array.isArray(rows) ? rows[0] : rows;
-          if (!first)
-            throw new Error("No rows found");
-          return first;
-        },
-        async exists() {
-          const countQ = sql`SELECT EXISTS(${q}) as exists`;
-          const result = await runWithHooks(countQ, "select");
-          return result?.[0]?.exists === true;
-        },
-        async doesntExist() {
-          const exists = await this.exists();
-          return !exists;
-        },
-        values() {
-          return q.values();
-        },
-        raw() {
-          return q.raw();
-        },
-        cancel() {
-          try {
-            q.cancel();
-          } catch {}
-        },
-        whereRaw: subqueryNotSupported("whereRaw"),
-        whereColumn: subqueryNotSupported("whereColumn"),
-        orWhereColumn: subqueryNotSupported("orWhereColumn"),
-        whereIn: subqueryNotSupported("whereIn"),
-        orWhereIn: subqueryNotSupported("orWhereIn"),
-        whereNotIn: subqueryNotSupported("whereNotIn"),
-        orWhereNotIn: subqueryNotSupported("orWhereNotIn"),
-        whereLike: subqueryNotSupported("whereLike"),
-        whereILike: subqueryNotSupported("whereILike"),
-        orWhereLike: subqueryNotSupported("orWhereLike"),
-        orWhereILike: subqueryNotSupported("orWhereILike"),
-        whereNotLike: subqueryNotSupported("whereNotLike"),
-        whereNotILike: subqueryNotSupported("whereNotILike"),
-        orWhereNotLike: subqueryNotSupported("orWhereNotLike"),
-        orWhereNotILike: subqueryNotSupported("orWhereNotILike"),
-        whereAny: subqueryNotSupported("whereAny"),
-        whereAll: subqueryNotSupported("whereAll"),
-        whereNone: subqueryNotSupported("whereNone"),
-        whereNested: subqueryNotSupported("whereNested"),
-        orWhereNested: subqueryNotSupported("orWhereNested"),
-        whereDate: subqueryNotSupported("whereDate"),
-        whereBetween: subqueryNotSupported("whereBetween"),
-        whereNotBetween: subqueryNotSupported("whereNotBetween"),
-        whereJsonContains: subqueryNotSupported("whereJsonContains"),
-        whereJsonPath: subqueryNotSupported("whereJsonPath"),
-        whereNull: subqueryNotSupported("whereNull"),
-        whereNotNull: subqueryNotSupported("whereNotNull"),
-        whereExists: subqueryNotSupported("whereExists"),
-        whereJsonDoesntContain: subqueryNotSupported("whereJsonDoesntContain"),
-        whereJsonContainsKey: subqueryNotSupported("whereJsonContainsKey"),
-        whereJsonDoesntContainKey: subqueryNotSupported("whereJsonDoesntContainKey"),
-        whereJsonLength: subqueryNotSupported("whereJsonLength"),
-        join: subqueryNotSupported("join"),
-        joinSub: subqueryNotSupported("joinSub"),
-        innerJoin: subqueryNotSupported("innerJoin"),
-        leftJoin: subqueryNotSupported("leftJoin"),
-        leftJoinSub: subqueryNotSupported("leftJoinSub"),
-        rightJoin: subqueryNotSupported("rightJoin"),
-        crossJoin: subqueryNotSupported("crossJoin"),
-        crossJoinSub: subqueryNotSupported("crossJoinSub"),
-        groupBy: subqueryNotSupported("groupBy"),
-        groupByRaw: subqueryNotSupported("groupByRaw"),
-        having: subqueryNotSupported("having"),
-        havingRaw: subqueryNotSupported("havingRaw"),
-        addSelect: subqueryNotSupported("addSelect"),
-        select: subqueryNotSupported("select"),
-        selectAll: subqueryNotSupported("selectAll"),
-        orderByDesc: subqueryNotSupported("orderByDesc"),
-        inRandomOrder: subqueryNotSupported("inRandomOrder"),
-        reorder: subqueryNotSupported("reorder"),
-        orderByRaw: subqueryNotSupported("orderByRaw"),
-        union: subqueryNotSupported("union"),
-        unionAll: subqueryNotSupported("unionAll"),
-        forPage: subqueryNotSupported("forPage"),
-        selectAllRelations: subqueryNotSupported("selectAllRelations"),
-        with: subqueryNotSupported("with"),
-        value: subqueryNotSupported("value"),
-        pluck: subqueryNotSupported("pluck"),
-        cursorPaginate: subqueryNotSupported("cursorPaginate"),
-        paginate: subqueryNotSupported("paginate"),
-        simplePaginate: subqueryNotSupported("simplePaginate"),
-        chunk: subqueryNotSupported("chunk"),
-        chunkById: subqueryNotSupported("chunkById"),
-        eachById: subqueryNotSupported("eachById"),
-        count: subqueryNotSupported("count"),
-        avg: subqueryNotSupported("avg"),
-        sum: subqueryNotSupported("sum"),
-        max: subqueryNotSupported("max"),
-        min: subqueryNotSupported("min"),
-        find: subqueryNotSupported("find"),
-        findOrFail: subqueryNotSupported("findOrFail"),
-        findMany: subqueryNotSupported("findMany"),
-        latest: subqueryNotSupported("latest"),
-        oldest: subqueryNotSupported("oldest"),
-        lazy: subqueryNotSupported("lazy"),
-        lazyById: subqueryNotSupported("lazyById"),
-        pipe: (fn) => fn(this),
-        when: subqueryNotSupported("when"),
-        tap: () => this,
-        dump: () => this,
-        dd: () => {
-          throw new Error("Dump and Die");
-        },
-        explain: () => Promise.resolve([]),
-        simple: () => q.simple(),
-        toText: () => String(q),
-        toParams: () => q.values?.() ?? [],
-        withTimeout: () => this,
-        abort: () => this,
-        lockForUpdate: () => this,
-        sharedLock: () => this,
-        withCTE: () => this,
-        withRecursive: () => this,
-        cache: () => this,
-        clone: () => this,
-        withTrashed: () => this,
-        onlyTrashed: () => this,
-        scope: () => this,
-        get rows() {
-          return [];
-        },
-        get row() {
-          return;
-        }
+      validateIdentifier(String(alias), "selectFromSub(alias)");
+      const rawState = typeof sub.__rawState === "function" ? sub.__rawState() : null;
+      const subExec = sub.toSQL();
+      const subText = rawState?.sql ?? (typeof subExec === "string" ? subExec : subExec?.sql ?? String(subExec));
+      const subParams = rawState?.params ?? (Array.isArray(subExec?.values) ? subExec.values : []);
+      const baseText = `SELECT * FROM (${subText}) AS ${String(alias)}`;
+      const appendWhere = (text, params, hasWhere, expr, op, value, connector) => {
+        const kw = !hasWhere ? "WHERE" : connector === "WHERE" ? "AND" : connector;
+        const out = [...params];
+        const cmp = (col, operator, val) => {
+          validateIdentifier(col, "selectFromSub where(column)");
+          const o = assertSafeWhereOperator(operator, "selectFromSub where(operator)");
+          if (o === "in" || o === "not in") {
+            const vals = Array.isArray(val) ? val : [val];
+            const phs = getPlaceholders(vals.length, out.length + 1);
+            out.push(...vals);
+            return `${col} ${o.toUpperCase()} (${phs})`;
+          }
+          const ph = getPlaceholder(out.length + 1);
+          out.push(val);
+          return `${col} ${o} ${ph}`;
+        };
+        let clause;
+        if (typeof expr === "string" && op !== undefined)
+          clause = cmp(expr, op, value);
+        else if (Array.isArray(expr) && expr.length === 3)
+          clause = cmp(expr[0], expr[1], expr[2]);
+        else if (expr && typeof expr === "object")
+          clause = Object.entries(expr).map(([k, v]) => cmp(k, "=", v)).join(" AND ");
+        else
+          return { text, params };
+        return { text: `${text} ${kw} ${clause}`, params: out };
       };
-      function createSubQueryBuilder(newQ) {
-        return {
-          ...base,
-          toSQL: () => makeExecutableQuery(newQ),
-          execute: () => runWithHooks(newQ, "select"),
-          get: () => runWithHooks(newQ, "select"),
-          first: async () => {
-            const rows = await runWithHooks(newQ, "select");
+      function makeSub(text, params, hasWhere = false) {
+        const build = () => params.length > 0 ? _sql.unsafe(text, params) : _sql.unsafe(text);
+        const base = {
+          distinct() {
+            return makeSub(text.replace(/^SELECT\s+/i, "SELECT DISTINCT "), params, hasWhere);
+          },
+          distinctOn(...columns) {
+            const cols = columns.map(String).join(", ");
+            return makeSub(text.replace(/^SELECT\s+/i, `SELECT DISTINCT ON (${cols}) `), params, hasWhere);
+          },
+          selectRaw(fragment) {
+            const frag = renderRawFragment(fragment, "selectFromSub.selectRaw(fragment)");
+            const fromIdx = text.indexOf(" FROM ");
+            const newText = fromIdx !== -1 ? `${text.slice(0, fromIdx)}, ${frag}${text.slice(fromIdx)}` : `${text}, ${frag}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          where(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "WHERE");
+            return makeSub(r.text, r.params, true);
+          },
+          andWhere(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "AND");
+            return makeSub(r.text, r.params, true);
+          },
+          orWhere(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "OR");
+            return makeSub(r.text, r.params, true);
+          },
+          orderBy(column, direction = "asc") {
+            validateIdentifier(String(column), "selectFromSub.orderBy(column)");
+            const dir = direction === "asc" ? "ASC" : "DESC";
+            const newText = SQL_PATTERNS.ORDER_BY.test(text) ? `${text}, ${column} ${dir}` : `${text} ORDER BY ${column} ${dir}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          limit(n) {
+            if (!Number.isInteger(n) || n < 0)
+              throw new TypeError(`[query-builder] selectFromSub.limit(n): expected non-negative integer, got ${n}`);
+            const newText = SQL_PATTERNS.LIMIT.test(text) ? text.replace(SQL_PATTERNS.LIMIT, ` LIMIT ${n}`) : `${text} LIMIT ${n}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          offset(n) {
+            if (!Number.isInteger(n) || n < 0)
+              throw new TypeError(`[query-builder] selectFromSub.offset(n): expected non-negative integer, got ${n}`);
+            const newText = SQL_PATTERNS.OFFSET.test(text) ? text.replace(SQL_PATTERNS.OFFSET, ` OFFSET ${n}`) : `${text} OFFSET ${n}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          toSQL() {
+            return makeExecutableQuery(build(), text);
+          },
+          async execute() {
+            return runWithHooks(build(), "select");
+          },
+          async executeTakeFirst() {
+            const rows = await runWithHooks(build(), "select");
             return Array.isArray(rows) ? rows[0] : rows;
           },
-          firstOrFail: async () => {
-            const rows = await runWithHooks(newQ, "select");
+          async executeTakeFirstOrThrow() {
+            const rows = await runWithHooks(build(), "select");
+            const first = Array.isArray(rows) ? rows[0] : rows;
+            if (!first)
+              throw new Error("Record not found");
+            return first;
+          },
+          async get() {
+            return runWithHooks(build(), "select");
+          },
+          async first() {
+            const rows = await runWithHooks(build(), "select");
+            return Array.isArray(rows) ? rows[0] : rows;
+          },
+          async firstOrFail() {
+            const rows = await runWithHooks(build(), "select");
             const first = Array.isArray(rows) ? rows[0] : rows;
             if (!first)
               throw new Error("No rows found");
             return first;
           },
-          exists: async () => {
-            const countQ = sql`SELECT EXISTS(${newQ}) as exists`;
-            const result = await runWithHooks(countQ, "select");
-            return result?.[0]?.exists === true;
+          async count() {
+            const q = params.length > 0 ? _sql.unsafe(`SELECT COUNT(*) as c FROM (${text}) as sub`, params) : _sql.unsafe(`SELECT COUNT(*) as c FROM (${text}) as sub`);
+            const rows = await runWithHooks(q, "select");
+            return Number(rows?.[0]?.c ?? 0);
+          },
+          async exists() {
+            const q = params.length > 0 ? _sql.unsafe(`SELECT EXISTS(${text}) as e`, params) : _sql.unsafe(`SELECT EXISTS(${text}) as e`);
+            const result = await runWithHooks(q, "select");
+            return Boolean(result?.[0]?.e);
+          },
+          async doesntExist() {
+            return !await base.exists();
+          },
+          values() {
+            return build().values();
           },
-          doesntExist: async () => {
-            const exists = await base.exists();
-            return !exists;
+          raw() {
+            return build().raw();
           },
-          values: () => newQ.values(),
-          raw: () => newQ.raw(),
-          cancel: () => {
+          cancel() {
             try {
-              newQ.cancel();
+              build().cancel();
             } catch {}
           },
-          simple: () => newQ.simple(),
-          toText: () => String(newQ),
-          toParams: () => newQ.values?.() ?? []
+          whereRaw: subqueryNotSupported("whereRaw"),
+          whereColumn: subqueryNotSupported("whereColumn"),
+          orWhereColumn: subqueryNotSupported("orWhereColumn"),
+          whereIn: subqueryNotSupported("whereIn"),
+          orWhereIn: subqueryNotSupported("orWhereIn"),
+          whereNotIn: subqueryNotSupported("whereNotIn"),
+          orWhereNotIn: subqueryNotSupported("orWhereNotIn"),
+          whereLike: subqueryNotSupported("whereLike"),
+          whereILike: subqueryNotSupported("whereILike"),
+          orWhereLike: subqueryNotSupported("orWhereLike"),
+          orWhereILike: subqueryNotSupported("orWhereILike"),
+          whereNotLike: subqueryNotSupported("whereNotLike"),
+          whereNotILike: subqueryNotSupported("whereNotILike"),
+          orWhereNotLike: subqueryNotSupported("orWhereNotLike"),
+          orWhereNotILike: subqueryNotSupported("orWhereNotILike"),
+          whereAny: subqueryNotSupported("whereAny"),
+          whereAll: subqueryNotSupported("whereAll"),
+          whereNone: subqueryNotSupported("whereNone"),
+          whereNested: subqueryNotSupported("whereNested"),
+          orWhereNested: subqueryNotSupported("orWhereNested"),
+          whereDate: subqueryNotSupported("whereDate"),
+          whereBetween: subqueryNotSupported("whereBetween"),
+          whereNotBetween: subqueryNotSupported("whereNotBetween"),
+          whereJsonContains: subqueryNotSupported("whereJsonContains"),
+          whereJsonPath: subqueryNotSupported("whereJsonPath"),
+          whereNull: subqueryNotSupported("whereNull"),
+          whereNotNull: subqueryNotSupported("whereNotNull"),
+          whereExists: subqueryNotSupported("whereExists"),
+          whereJsonDoesntContain: subqueryNotSupported("whereJsonDoesntContain"),
+          whereJsonContainsKey: subqueryNotSupported("whereJsonContainsKey"),
+          whereJsonDoesntContainKey: subqueryNotSupported("whereJsonDoesntContainKey"),
+          whereJsonLength: subqueryNotSupported("whereJsonLength"),
+          join: subqueryNotSupported("join"),
+          joinSub: subqueryNotSupported("joinSub"),
+          innerJoin: subqueryNotSupported("innerJoin"),
+          leftJoin: subqueryNotSupported("leftJoin"),
+          leftJoinSub: subqueryNotSupported("leftJoinSub"),
+          rightJoin: subqueryNotSupported("rightJoin"),
+          crossJoin: subqueryNotSupported("crossJoin"),
+          crossJoinSub: subqueryNotSupported("crossJoinSub"),
+          groupBy: subqueryNotSupported("groupBy"),
+          groupByRaw: subqueryNotSupported("groupByRaw"),
+          having: subqueryNotSupported("having"),
+          havingRaw: subqueryNotSupported("havingRaw"),
+          addSelect: subqueryNotSupported("addSelect"),
+          select: subqueryNotSupported("select"),
+          selectAll: subqueryNotSupported("selectAll"),
+          orderByDesc: subqueryNotSupported("orderByDesc"),
+          inRandomOrder: subqueryNotSupported("inRandomOrder"),
+          reorder: subqueryNotSupported("reorder"),
+          orderByRaw: subqueryNotSupported("orderByRaw"),
+          union: subqueryNotSupported("union"),
+          unionAll: subqueryNotSupported("unionAll"),
+          forPage: subqueryNotSupported("forPage"),
+          selectAllRelations: subqueryNotSupported("selectAllRelations"),
+          with: subqueryNotSupported("with"),
+          value: subqueryNotSupported("value"),
+          pluck: subqueryNotSupported("pluck"),
+          cursorPaginate: subqueryNotSupported("cursorPaginate"),
+          paginate: subqueryNotSupported("paginate"),
+          simplePaginate: subqueryNotSupported("simplePaginate"),
+          chunk: subqueryNotSupported("chunk"),
+          chunkById: subqueryNotSupported("chunkById"),
+          eachById: subqueryNotSupported("eachById"),
+          avg: subqueryNotSupported("avg"),
+          sum: subqueryNotSupported("sum"),
+          max: subqueryNotSupported("max"),
+          min: subqueryNotSupported("min"),
+          find: subqueryNotSupported("find"),
+          findOrFail: subqueryNotSupported("findOrFail"),
+          findMany: subqueryNotSupported("findMany"),
+          latest: subqueryNotSupported("latest"),
+          oldest: subqueryNotSupported("oldest"),
+          lazy: subqueryNotSupported("lazy"),
+          lazyById: subqueryNotSupported("lazyById"),
+          pipe: (fn) => fn(base),
+          when: subqueryNotSupported("when"),
+          tap: () => base,
+          dump: () => base,
+          dd: () => {
+            throw new Error("Dump and Die");
+          },
+          explain: () => Promise.resolve([]),
+          simple: () => build().simple(),
+          toText: () => text,
+          toParams: () => [...params],
+          withTimeout: () => base,
+          abort: () => base,
+          lockForUpdate: () => base,
+          sharedLock: () => base,
+          withCTE: () => base,
+          withRecursive: () => base,
+          cache: () => base,
+          clone: () => base,
+          withTrashed: () => base,
+          onlyTrashed: () => base,
+          scope: () => base,
+          get rows() {
+            return [];
+          },
+          get row() {
+            return;
+          }
         };
+        return base;
       }
-      function applyWhereCondition(query, expr, op, value, prefix = "WHERE") {
-        if (typeof expr === "string" && op !== undefined) {
-          const clause = Array.isArray(value) ? `${expr} IN (?)` : `${expr} ${op} ?`;
-          return sql`${query} ${sql(prefix)} ${sql(clause)}`;
-        } else if (Array.isArray(expr) && expr.length === 3) {
-          const [column, operator, val] = expr;
-          const clause = Array.isArray(val) ? `${column} IN (?)` : `${column} ${operator} ?`;
-          return sql`${query} ${sql(prefix)} ${sql(clause)}`;
-        } else if (typeof expr === "object" && expr !== null) {
-          const conditions = Object.entries(expr).map(([key, val]) => {
-            const clause = Array.isArray(val) ? `${key} IN (?)` : `${key} = ?`;
-            return sql`${sql(clause)}`;
-          });
-          const combined = conditions.reduce((acc, cond, i) => i === 0 ? cond : sql`${acc} AND ${cond}`);
-          return sql`${query} ${sql(prefix)} ${combined}`;
-        }
-        return query;
-      }
-      return base;
+      return makeSub(baseText, subParams);
     },
     insertInto(table) {
       let built;
@@ -15892,12 +15911,15 @@ function createQueryBuilder(state) {
     async transaction(fn, options) {
       const defaults = state?.txDefaults;
       const opts = { ...defaults, ...options };
+      const txConn = state?.sql ?? bunSql;
+      const nested = state?.inTransaction === true;
+      const txMethod = nested && typeof txConn?.savepoint === "function" ? "savepoint" : "begin";
       const runWith = async (attempt2) => {
         opts.logger?.({ type: "start", attempt: attempt2 });
         const start = Date.now();
-        return await bunSql.begin(async (tx) => {
-          const qb = createQueryBuilder({ sql: tx, meta, schema });
-          if (opts?.isolation) {
+        return await txConn[txMethod](async (tx) => {
+          const qb = createQueryBuilder({ sql: tx, meta, schema, inTransaction: true });
+          if (opts?.isolation && !nested) {
             const level = opts.isolation;
             const upper = level === "read committed" ? "READ COMMITTED" : level === "repeatable read" ? "REPEATABLE READ" : "SERIALIZABLE";
             if (config5.dialect === "postgres") {
@@ -15962,7 +15984,8 @@ function createQueryBuilder(state) {
       });
     },
     async beginDistributed(name, fn) {
-      const res = await bunSql.beginDistributed(name, async (tx) => {
+      const txConn = state?.sql ?? bunSql;
+      const res = await txConn.beginDistributed(name, async (tx) => {
         const qb = createQueryBuilder({ sql: tx, meta, schema });
         return await fn(qb);
       });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-query-builder",
   "type": "module",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "A simple yet performant query builder for TypeScript. Built with Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",