bun-query-builder 0.2.27 → 0.2.29

package/dist/bin/cli.js

@@ -12555,6 +12555,30 @@ var init_pivot = __esm(() => {
   init_config();
 });
 
+// src/sql-fragments.ts
+function renderWhereTerms(terms) {
+  if (terms.length === 0)
+    return "";
+  const runs = [];
+  for (const term of terms) {
+    if (term.conn === "OR" && runs.length > 0)
+      runs[runs.length - 1].push(term);
+    else
+      runs.push([term]);
+  }
+  return runs.map((run, i) => {
+    const body = run.map((t) => t.sql).join(" OR ");
+    const piece = run.length > 1 && runs.length > 1 ? `(${body})` : body;
+    return i === 0 ? piece : `${run[0].conn} ${piece}`;
+  }).join(" ");
+}
+function renderInPredicate(column, values, negated, placeholders) {
+  if (values.length === 0)
+    return negated ? TRUE_PREDICATE : FALSE_PREDICATE;
+  return `${column} ${negated ? "NOT IN" : "IN"} (${placeholders})`;
+}
+var FALSE_PREDICATE = "1 = 0", TRUE_PREDICATE = "1 = 1";
+
 // src/client.ts
 function isRawExpression(expr) {
   return typeof expr === "object" && expr !== null && "raw" in expr && typeof expr.raw === "string";
@@ -12626,11 +12650,6 @@ function renderSelectColumn(col) {
   }
   throw new TypeError(`[query-builder] select(): unsupported column ${String(col)} \u2014 pass a column name, a string[], or a SQL fragment (e.g. sql\`count(*) as c\`)`);
 }
-function renderInPredicate(column, values, negated, placeholders) {
-  if (values.length === 0)
-    return negated ? TRUE_PREDICATE : FALSE_PREDICATE;
-  return `${column} ${negated ? "NOT IN" : "IN"} (${placeholders})`;
-}
 function validateIdentifier(name, context) {
   if (!SQL_PATTERNS.IDENTIFIER.test(name)) {
     const contextMsg = context ? ` in ${context}` : "";
@@ -13107,20 +13126,125 @@ function createQueryBuilder(state) {
   function makeSelect(table, columns) {
     const sql = _sql;
     let text = columns && columns.length > 0 ? `SELECT ${columns.join(", ")} FROM ${String(table)}` : `SELECT * FROM ${String(table)}`;
+    const whereTerms = [];
+    const whereParams = [];
+    let whereTail = false;
     let built = null;
     const ensureBuilt = () => {
       if (built === null) {
-        const finalText = reorderSelectClauses(text);
+        const finalText = reorderSelectClauses(currentSql());
         built = whereParams.length > 0 ? _sql.unsafe(finalText, whereParams) : _sql.unsafe(finalText);
       }
       return built;
     };
+    const pushWhere = (conn, clause) => {
+      whereTerms.push({ conn, sql: clause });
+      built = null;
+    };
     const addWhereText = (prefix, clause) => {
-      const hasWhere = SQL_PATTERNS.WHERE.test(text);
-      const p = !hasWhere ? "WHERE" : prefix === "WHERE" ? "AND" : prefix;
-      text = `${text} ${p} ${clause}`;
+      pushWhere(prefix === "OR" ? "OR" : "AND", clause);
+    };
+    const TAIL_CLAUSE = /\(|\)|\b(?:GROUP\s+BY|HAVING|ORDER\s+BY|LIMIT|OFFSET|WINDOW|UNION|INTERSECT|EXCEPT|FOR\s+UPDATE|FOR\s+SHARE|LOCK\s+IN\s+SHARE\s+MODE)\b/gi;
+    const firstTailIndex = (s) => {
+      TAIL_CLAUSE.lastIndex = 0;
+      let depth = 0;
+      let m;
+      while (m = TAIL_CLAUSE.exec(s)) {
+        if (m[0] === "(") {
+          depth++;
+        } else if (m[0] === ")") {
+          depth = Math.max(0, depth - 1);
+        } else if (depth === 0) {
+          return m.index;
+        }
+      }
+      return -1;
+    };
+    const currentSql = () => {
+      const body = renderWhereTerms(whereTerms);
+      if (!body)
+        return text;
+      if (whereTail) {
+        const kw = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
+        return `${text} ${kw} ${body}`;
+      }
+      const cut = firstTailIndex(text);
+      return cut >= 0 ? `${text.slice(0, cut)}WHERE ${body} ${text.slice(cut)}` : `${text} WHERE ${body}`;
+    };
+    const addWhereGroup = (conn, cb) => {
+      const sub = makeSelect(table);
+      cb(sub);
+      const st = sub.__whereState?.();
+      if (!st || !st.body) {
+        throw new TypeError("[query-builder] whereGroup(callback): the callback added no conditions. " + "Add at least one where()/orWhere() to the builder it receives.");
+      }
+      const offset = whereParams.length;
+      const body = offset > 0 && config5.dialect === "postgres" ? st.body.replace(/\$(\d+)/g, (_m, n) => `$${Number(n) + offset}`) : st.body;
+      whereParams.push(...st.params);
+      pushWhere(conn, `(${body})`);
+    };
+    const addBooleanWhere = (self, conn, label, expr, op, value) => {
+      if (typeof expr === "string" && op !== undefined) {
+        validateIdentifier(String(expr), `${label}(column)`);
+        assertSafeWhereOperator(op, `${label}(operator)`);
+        const paramIndex = whereParams.length + 1;
+        whereParams.push(value);
+        pushWhere(conn, `${String(expr)} ${String(op)} ${getPlaceholder(paramIndex)}`);
+        return self;
+      }
+      if (Array.isArray(expr)) {
+        const [col, rawOp, val] = expr;
+        const colName = String(col);
+        validateIdentifier(colName, `${label}(column)`);
+        const operator = assertSafeWhereOperator(rawOp, `${label}(operator)`);
+        if (operator === "in" || operator === "not in") {
+          const values = Array.isArray(val) ? val : [val];
+          const placeholders = getPlaceholders(values.length, whereParams.length + 1);
+          const clause = renderInPredicate(colName, values, operator === "not in", placeholders);
+          whereParams.push(...values);
+          pushWhere(conn, clause);
+        } else {
+          const paramIndex = whereParams.length + 1;
+          whereParams.push(val);
+          pushWhere(conn, `${colName} ${operator} ${getPlaceholder(paramIndex)}`);
+        }
+        return self;
+      }
+      if (typeof expr === "function") {
+        addWhereGroup(conn, expr);
+        return self;
+      }
+      if (expr && typeof expr === "object" && !("raw" in expr)) {
+        const conditions = [];
+        for (const key of Object.keys(expr)) {
+          validateIdentifier(key, `${label}(column)`);
+          const v = expr[key];
+          if (Array.isArray(v)) {
+            const placeholders = getPlaceholders(v.length, whereParams.length + 1);
+            conditions.push(renderInPredicate(key, v, false, placeholders));
+            whereParams.push(...v);
+          } else {
+            const paramIndex = whereParams.length + 1;
+            conditions.push(`${key} = ${getPlaceholder(paramIndex)}`);
+            whereParams.push(v);
+          }
+        }
+        if (conditions.length > 0)
+          pushWhere(conn, conditions.length > 1 ? `(${conditions.join(" AND ")})` : conditions[0]);
+        return self;
+      }
+      if (expr && typeof expr.raw !== "undefined") {
+        pushWhere(conn, expr.raw);
+        return self;
+      }
+      return self;
     };
     const appendSetOp = (op, other) => {
+      if (whereTerms.length > 0) {
+        text = currentSql();
+        whereTerms.length = 0;
+      }
+      whereTail = true;
       const st = other.__rawState?.();
       if (st) {
         const offset = whereParams.length;
@@ -13210,8 +13334,6 @@ function createQueryBuilder(state) {
       text = `${text} LEFT JOIN ${resolved.pivotTable} ON ${resolved.pivotTable}.${resolved.fkParent} = ${parentTable}.${parentPk}`;
       joinedTables.add(resolved.pivotTable);
     };
-    const whereConditions = [];
-    const whereParams = [];
     const addToSelectClause = (columnsToAdd) => {
       if (SQL_PATTERNS.SELECT_STAR.test(text)) {
         text = text.replace(SQL_PATTERNS.SELECT_STAR, `SELECT *, ${columnsToAdd}`);
@@ -13835,10 +13957,7 @@ function createQueryBuilder(state) {
         } else {
           throw new Error(`[query-builder] Unsupported relationship type '${type}' for whereHas`);
         }
-        built = sql`${ensureBuilt()} WHERE EXISTS (${sql([subquerySQL])})`;
-        try {
-          addWhereText("WHERE", `EXISTS (${subquerySQL})`);
-        } catch {}
+        addWhereText("WHERE", `EXISTS (${subquerySQL})`);
         return this;
       },
       whereDoesntHave(relation, callback) {
@@ -13871,10 +13990,7 @@ function createQueryBuilder(state) {
         } else {
           throw new Error(`[query-builder] Unsupported relationship type '${type}' for whereDoesntHave`);
         }
-        built = sql`${ensureBuilt()} WHERE NOT EXISTS (${sql([subquerySQL])})`;
-        try {
-          addWhereText("WHERE", `NOT EXISTS (${subquerySQL})`);
-        } catch {}
+        addWhereText("WHERE", `NOT EXISTS (${subquerySQL})`);
         return this;
       },
       has(relation) {
@@ -13905,10 +14021,7 @@ function createQueryBuilder(state) {
         } else {
           throw new Error(`[query-builder] Unsupported relationship type '${type}' for has`);
         }
-        built = sql`${ensureBuilt()} WHERE EXISTS (${sql([subquerySQL])})`;
-        try {
-          addWhereText("WHERE", `EXISTS (${subquerySQL})`);
-        } catch {}
+        addWhereText("WHERE", `EXISTS (${subquerySQL})`);
         return this;
       },
       doesntHave(relation) {
@@ -13939,10 +14052,7 @@ function createQueryBuilder(state) {
         } else {
           throw new Error(`[query-builder] Unsupported relationship type '${type}' for doesntHave`);
         }
-        built = sql`${ensureBuilt()} WHERE NOT EXISTS (${sql([subquerySQL])})`;
-        try {
-          addWhereText("WHERE", `NOT EXISTS (${subquerySQL})`);
-        } catch {}
+        addWhereText("WHERE", `NOT EXISTS (${subquerySQL})`);
         return this;
       },
       withCount(...relations) {
@@ -14025,17 +14135,14 @@ function createQueryBuilder(state) {
         const val = value === undefined ? opOrValue : value;
         const paramIndex = whereParams.length + 1;
         const clause = `${resolved.pivotTable}.${column} ${op} ${getPlaceholder(paramIndex)}`;
-        whereConditions.push(clause);
         whereParams.push(val);
-        const kw = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text = `${text} ${kw} ${clause}`;
-        built = null;
+        pushWhere("AND", clause);
         if (resolved.hasConfig)
           pivotConfigRelations.add(relation);
         return this;
       },
       wherePivotIn(relation, column, values) {
-        if (!meta || !Array.isArray(values) || values.length === 0)
+        if (!meta || !Array.isArray(values))
           return this;
         const resolved = resolvePivotLocal(relation);
         if (!resolved) {
@@ -14045,12 +14152,9 @@ function createQueryBuilder(state) {
         validateIdentifier(column, "wherePivotIn (column)");
         ensurePivotJoined(resolved);
         const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-        const clause = `${resolved.pivotTable}.${column} IN (${placeholders})`;
-        whereConditions.push(clause);
+        const clause = renderInPredicate(`${resolved.pivotTable}.${column}`, values, false, placeholders);
         whereParams.push(...values);
-        const kw = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text = `${text} ${kw} ${clause}`;
-        built = null;
+        pushWhere("AND", clause);
         if (resolved.hasConfig)
           pivotConfigRelations.add(relation);
         return this;
@@ -14067,11 +14171,8 @@ function createQueryBuilder(state) {
         ensurePivotJoined(resolved);
         const placeholders = getPlaceholders(values.length, whereParams.length + 1);
         const clause = `${resolved.pivotTable}.${column} NOT IN (${placeholders})`;
-        whereConditions.push(clause);
         whereParams.push(...values);
-        const kw = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text = `${text} ${kw} ${clause}`;
-        built = null;
+        pushWhere("AND", clause);
         if (resolved.hasConfig)
           pivotConfigRelations.add(relation);
         return this;
@@ -14086,11 +14187,7 @@ function createQueryBuilder(state) {
         validateIdentifier(resolved.pivotTable, "wherePivotNull (pivot table)");
         validateIdentifier(column, "wherePivotNull (column)");
         ensurePivotJoined(resolved);
-        const clause = `${resolved.pivotTable}.${column} IS NULL`;
-        whereConditions.push(clause);
-        const kw = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text = `${text} ${kw} ${clause}`;
-        built = null;
+        pushWhere("AND", `${resolved.pivotTable}.${column} IS NULL`);
         if (resolved.hasConfig)
           pivotConfigRelations.add(relation);
         return this;
@@ -14105,17 +14202,12 @@ function createQueryBuilder(state) {
         validateIdentifier(resolved.pivotTable, "wherePivotNotNull (pivot table)");
         validateIdentifier(column, "wherePivotNotNull (column)");
         ensurePivotJoined(resolved);
-        const clause = `${resolved.pivotTable}.${column} IS NOT NULL`;
-        whereConditions.push(clause);
-        const kw = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text = `${text} ${kw} ${clause}`;
-        built = null;
+        pushWhere("AND", `${resolved.pivotTable}.${column} IS NOT NULL`);
         if (resolved.hasConfig)
           pivotConfigRelations.add(relation);
         return this;
       },
       where(expr, op, value) {
-        const getWhereKeyword = () => SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         if (typeof expr === "string" && op !== undefined) {
           validateIdentifier(String(expr), "where(column)");
           assertSafeWhereOperator(op, "where(operator)");
@@ -14123,18 +14215,14 @@ function createQueryBuilder(state) {
           if (operator === "in" || operator === "not in") {
             const values = Array.isArray(value) ? value : [value];
             const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-            const clause = `${String(expr)} ${operator.toUpperCase()} (${placeholders})`;
-            whereConditions.push(clause);
+            const clause = renderInPredicate(String(expr), values, operator === "not in", placeholders);
             whereParams.push(...values);
-            text = `${text} ${getWhereKeyword()} ${clause}`;
-            built = null;
+            pushWhere("AND", clause);
             return this;
           }
           const paramIndex = whereParams.length + 1;
-          whereConditions.push(`${String(expr)} ${String(op)} ${getPlaceholder(paramIndex)}`);
           whereParams.push(value);
-          text = `${text} ${getWhereKeyword()} ${String(expr)} ${String(op)} ${getPlaceholder(paramIndex)}`;
-          built = null;
+          pushWhere("AND", `${String(expr)} ${String(op)} ${getPlaceholder(paramIndex)}`);
           return this;
         }
         if (Array.isArray(expr)) {
@@ -14145,16 +14233,13 @@ function createQueryBuilder(state) {
           if (operator === "in" || operator === "not in") {
             const values = Array.isArray(val) ? val : [val];
             const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-            whereConditions.push(`${colName} ${operator.toUpperCase()} (${placeholders})`);
+            const clause = renderInPredicate(colName, values, operator === "not in", placeholders);
             whereParams.push(...values);
-            text = `${text} ${getWhereKeyword()} ${colName} ${operator.toUpperCase()} (${placeholders})`;
-            built = null;
+            pushWhere("AND", clause);
           } else {
             const paramIndex = whereParams.length + 1;
-            whereConditions.push(`${colName} ${operator} ${getPlaceholder(paramIndex)}`);
             whereParams.push(val);
-            text = `${text} ${getWhereKeyword()} ${colName} ${operator} ${getPlaceholder(paramIndex)}`;
-            built = null;
+            pushWhere("AND", `${colName} ${operator} ${getPlaceholder(paramIndex)}`);
           }
           return this;
         }
@@ -14167,30 +14252,25 @@ function createQueryBuilder(state) {
             const value2 = whereObject[key];
             if (Array.isArray(value2)) {
               const placeholders = getPlaceholders(value2.length, whereParams.length + 1);
-              conditions.push(`${key} IN (${placeholders})`);
-              whereConditions.push(`${key} IN (${placeholders})`);
+              conditions.push(renderInPredicate(key, value2, false, placeholders));
               whereParams.push(...value2);
             } else {
               const paramIndex = whereParams.length + 1;
               conditions.push(`${key} = ${getPlaceholder(paramIndex)}`);
-              whereConditions.push(`${key} = ${getPlaceholder(paramIndex)}`);
               whereParams.push(value2);
             }
           }
-          if (conditions.length > 0) {
-            text = `${text} ${getWhereKeyword()} ${conditions.join(" AND ")}`;
-            built = null;
-          }
+          if (conditions.length > 0)
+            pushWhere("AND", conditions.length > 1 ? `(${conditions.join(" AND ")})` : conditions[0]);
           return this;
         }
         if (isRawExpression(expr)) {
-          whereConditions.push(expr.raw);
-          text = `${text} ${getWhereKeyword()} ${expr.raw}`;
-          built = null;
+          pushWhere("AND", expr.raw);
           return this;
         }
         if (typeof expr === "function") {
-          throw new TypeError("where(callback) is not supported. This builder has no expression callback, and " + "ignoring one silently would leave the query matching every row the filter was " + "meant to exclude. Use whereNested(subquery), whereAny(...), or the orWhere* " + "helpers to build a grouped condition.");
+          addWhereGroup("AND", expr);
+          return this;
         }
         if (expr === undefined || expr === null) {
           throw new TypeError("where() was called with no condition.");
@@ -14202,61 +14282,83 @@ function createQueryBuilder(state) {
       },
       whereNull(column) {
         validateIdentifier(String(column), "whereNull(column)");
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text = `${text} ${keyword} ${String(column)} IS NULL`;
-        built = null;
+        pushWhere("AND", `${String(column)} IS NULL`);
         return this;
       },
       whereNotNull(column) {
         validateIdentifier(String(column), "whereNotNull(column)");
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text = `${text} ${keyword} ${String(column)} IS NOT NULL`;
-        built = null;
+        pushWhere("AND", `${String(column)} IS NOT NULL`);
+        return this;
+      },
+      orWhereNull(column) {
+        validateIdentifier(String(column), "orWhereNull(column)");
+        pushWhere("OR", `${String(column)} IS NULL`);
+        return this;
+      },
+      orWhereNotNull(column) {
+        validateIdentifier(String(column), "orWhereNotNull(column)");
+        pushWhere("OR", `${String(column)} IS NOT NULL`);
         return this;
       },
       whereBetween(column, start, end) {
         validateIdentifier(String(column), "whereBetween(column)");
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         const i = whereParams.length + 1;
-        text = `${text} ${keyword} ${String(column)} BETWEEN ${getPlaceholder(i)} AND ${getPlaceholder(i + 1)}`;
         whereParams.push(start, end);
-        built = null;
+        pushWhere("AND", `${String(column)} BETWEEN ${getPlaceholder(i)} AND ${getPlaceholder(i + 1)}`);
+        return this;
+      },
+      orWhereBetween(column, start, end) {
+        validateIdentifier(String(column), "orWhereBetween(column)");
+        const i = whereParams.length + 1;
+        whereParams.push(start, end);
+        pushWhere("OR", `${String(column)} BETWEEN ${getPlaceholder(i)} AND ${getPlaceholder(i + 1)}`);
         return this;
       },
       whereExists(subquery) {
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text = `${text} ${keyword} EXISTS (${subquery.toSQL()})`;
-        built = null;
+        pushWhere("AND", `EXISTS (${subquery.toSQL()})`);
+        return this;
+      },
+      orWhereExists(subquery) {
+        pushWhere("OR", `EXISTS (${subquery.toSQL()})`);
+        return this;
+      },
+      whereGroup(cb) {
+        addWhereGroup("AND", cb);
+        return this;
+      },
+      orWhereGroup(cb) {
+        addWhereGroup("OR", cb);
         return this;
       },
+      __whereState() {
+        return { body: renderWhereTerms(whereTerms), params: [...whereParams] };
+      },
       whereJsonContains(column, json) {
         validateIdentifier(String(column), "whereJsonContains(column)");
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         const dialect = config5.dialect;
         const idx = whereParams.length + 1;
         if (dialect === "postgres") {
           if (config5.sql?.jsonContainsMode === "function")
-            text += ` ${keyword} jsonb_contains(${column}, ${getPlaceholder(idx)})`;
+            pushWhere("AND", `jsonb_contains(${column}, ${getPlaceholder(idx)})`);
           else
-            text += ` ${keyword} ${column} @> ${getPlaceholder(idx)}`;
+            pushWhere("AND", `${column} @> ${getPlaceholder(idx)}`);
           whereParams.push(JSON.stringify(json));
         } else if (isMysqlLike(dialect)) {
-          text += ` ${keyword} JSON_CONTAINS(${column}, ${getPlaceholder(idx)})`;
+          pushWhere("AND", `JSON_CONTAINS(${column}, ${getPlaceholder(idx)})`);
           whereParams.push(JSON.stringify(json));
         } else {
           if (Array.isArray(json)) {
             const conds = json.map((_, i) => `EXISTS (SELECT 1 FROM json_each(${column}) WHERE json_each.value = ${getPlaceholder(idx + i)})`);
-            text += ` ${keyword} (${conds.join(" AND ")})`;
+            pushWhere("AND", `(${conds.join(" AND ")})`);
             for (const v of json)
               whereParams.push(v);
           } else if (json !== null && typeof json === "object") {
             throw new Error("[query-builder] whereJsonContains: object containment is not supported on SQLite \u2014 pass a scalar or array, or use whereJsonPath.");
           } else {
-            text += ` ${keyword} EXISTS (SELECT 1 FROM json_each(${column}) WHERE json_each.value = ${getPlaceholder(idx)})`;
+            pushWhere("AND", `EXISTS (SELECT 1 FROM json_each(${column}) WHERE json_each.value = ${getPlaceholder(idx)})`);
             whereParams.push(json);
           }
         }
-        built = null;
         return this;
       },
       whereJsonPath(path, op, value) {
@@ -14266,17 +14368,14 @@ function createQueryBuilder(state) {
         if (!/^[A-Za-z0-9_.[\]$'\->* ,]+$/.test(path))
           throw new TypeError(`[query-builder] whereJsonPath(path): refusing to use '${path}' \u2014 contains characters outside the allowed JSON-path set`);
         const dialect = config5.dialect;
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         const idx = whereParams.length + 1;
-        if (dialect === "postgres") {
-          text += ` ${keyword} ${path} ${op} ${getPlaceholder(idx)}`;
-        } else if (isMysqlLike(dialect)) {
-          text += ` ${keyword} JSON_EXTRACT(${path}) ${op} ${getPlaceholder(idx)}`;
-        } else {
-          text += ` ${keyword} json_extract(${path}) ${op} ${getPlaceholder(idx)}`;
-        }
+        if (dialect === "postgres")
+          pushWhere("AND", `${path} ${op} ${getPlaceholder(idx)}`);
+        else if (isMysqlLike(dialect))
+          pushWhere("AND", `JSON_EXTRACT(${path}) ${op} ${getPlaceholder(idx)}`);
+        else
+          pushWhere("AND", `json_extract(${path}) ${op} ${getPlaceholder(idx)}`);
         whereParams.push(value);
-        built = null;
         return this;
       },
       whereLike(column, pattern, caseSensitive = false) {
@@ -14349,51 +14448,41 @@ function createQueryBuilder(state) {
       },
       whereAny(cols, op, value) {
         if (cols.length === 0) {
-          const kw = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-          text += ` ${kw} (${FALSE_PREDICATE})`;
-          built = null;
+          pushWhere("AND", `(${FALSE_PREDICATE})`);
           return this;
         }
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         const idx = whereParams.length + 1;
         const conds = cols.map((c, i) => `${c} ${op} ${getPlaceholder(idx + i)}`);
-        text += ` ${keyword} (${conds.join(" OR ")})`;
         for (let i = 0;i < cols.length; i++)
           whereParams.push(value);
-        built = null;
+        pushWhere("AND", `(${conds.join(" OR ")})`);
         return this;
       },
       whereAll(cols, op, value) {
         if (cols.length === 0)
           return this;
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         const idx = whereParams.length + 1;
         const conds = cols.map((c, i) => `${c} ${op} ${getPlaceholder(idx + i)}`);
-        text += ` ${keyword} (${conds.join(" AND ")})`;
         for (let i = 0;i < cols.length; i++)
           whereParams.push(value);
-        built = null;
+        pushWhere("AND", `(${conds.join(" AND ")})`);
         return this;
       },
       whereNone(cols, op, value) {
         if (cols.length === 0)
           return this;
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         const idx = whereParams.length + 1;
         const conds = cols.map((c, i) => `${c} ${op} ${getPlaceholder(idx + i)}`);
-        text += ` ${keyword} NOT (${conds.join(" OR ")})`;
         for (let i = 0;i < cols.length; i++)
           whereParams.push(value);
-        built = null;
+        pushWhere("AND", `NOT (${conds.join(" OR ")})`);
         return this;
       },
       whereNotBetween(column, start, end) {
         validateIdentifier(String(column), "whereNotBetween(column)");
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         const i = whereParams.length + 1;
-        text += ` ${keyword} ${column} NOT BETWEEN ${getPlaceholder(i)} AND ${getPlaceholder(i + 1)}`;
         whereParams.push(start, end);
-        built = null;
+        pushWhere("AND", `${column} NOT BETWEEN ${getPlaceholder(i)} AND ${getPlaceholder(i + 1)}`);
         return this;
       },
       whereDate(column, op, date) {
@@ -14401,223 +14490,94 @@ function createQueryBuilder(state) {
         const dateString = date instanceof Date ? date.toISOString() : typeof date === "string" ? date : (() => {
           throw new TypeError(`[query-builder] whereDate(date): expected string or Date, got ${typeof date}`);
         })();
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         const idx = whereParams.length + 1;
-        text += ` ${keyword} ${column} ${op} ${getPlaceholder(idx)}`;
         whereParams.push(dateString);
-        built = null;
+        pushWhere("AND", `${column} ${op} ${getPlaceholder(idx)}`);
         return this;
       },
       whereRaw(fragment) {
-        const frag = renderRawFragment(fragment, "whereRaw(fragment)");
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text += ` ${keyword} ${frag}`;
-        built = null;
+        pushWhere("AND", renderRawFragment(fragment, "whereRaw(fragment)"));
+        return this;
+      },
+      orWhereRaw(fragment) {
+        pushWhere("OR", renderRawFragment(fragment, "orWhereRaw(fragment)"));
         return this;
       },
       whereColumn(left, op, right) {
         validateIdentifier(left, "whereColumn(left)");
         validateIdentifier(right, "whereColumn(right)");
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text += ` ${keyword} ${left} ${op} ${right}`;
-        built = null;
+        pushWhere("AND", `${left} ${op} ${right}`);
         return this;
       },
       orWhereColumn(left, op, right) {
         validateIdentifier(left, "orWhereColumn(left)");
         validateIdentifier(right, "orWhereColumn(right)");
-        text += ` OR ${left} ${op} ${right}`;
-        built = null;
+        pushWhere("OR", `${left} ${op} ${right}`);
         return this;
       },
       whereIn(column, values) {
         validateIdentifier(String(column), "whereIn(column)");
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         if (Array.isArray(values)) {
           const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-          text += ` ${keyword} ${renderInPredicate(column, values, false, placeholders)}`;
+          const clause = renderInPredicate(column, values, false, placeholders);
           whereParams.push(...values);
+          pushWhere("AND", clause);
         } else {
-          text += ` ${keyword} ${column} IN (${String(values.toSQL())})`;
+          pushWhere("AND", `${column} IN (${String(values.toSQL())})`);
         }
-        built = null;
         return this;
       },
       orWhereIn(column, values) {
         validateIdentifier(String(column), "orWhereIn(column)");
         if (Array.isArray(values)) {
           const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-          text += ` OR ${renderInPredicate(column, values, false, placeholders)}`;
+          const clause = renderInPredicate(column, values, false, placeholders);
           whereParams.push(...values);
+          pushWhere("OR", clause);
         } else {
-          text += ` OR ${column} IN (${String(values.toSQL())})`;
+          pushWhere("OR", `${column} IN (${String(values.toSQL())})`);
         }
-        built = null;
         return this;
       },
       whereNotIn(column, values) {
         validateIdentifier(String(column), "whereNotIn(column)");
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         if (Array.isArray(values)) {
           const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-          text += ` ${keyword} ${renderInPredicate(column, values, true, placeholders)}`;
+          const clause = renderInPredicate(column, values, true, placeholders);
           whereParams.push(...values);
+          pushWhere("AND", clause);
         } else {
-          text += ` ${keyword} ${column} NOT IN (${String(values.toSQL())})`;
+          pushWhere("AND", `${column} NOT IN (${String(values.toSQL())})`);
         }
-        built = null;
         return this;
       },
       orWhereNotIn(column, values) {
         validateIdentifier(String(column), "orWhereNotIn(column)");
         if (Array.isArray(values)) {
           const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-          text += ` OR ${renderInPredicate(column, values, true, placeholders)}`;
+          const clause = renderInPredicate(column, values, true, placeholders);
           whereParams.push(...values);
+          pushWhere("OR", clause);
         } else {
-          text += ` OR ${column} NOT IN (${String(values.toSQL())})`;
+          pushWhere("OR", `${column} NOT IN (${String(values.toSQL())})`);
         }
-        built = null;
         return this;
       },
       whereNested(fragment) {
-        const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
         const inner = fragment.toSQL ? String(fragment.toSQL()) : String(fragment);
-        text += ` ${keyword} (${inner})`;
-        built = null;
+        pushWhere("AND", `(${inner})`);
         return this;
       },
       orWhereNested(fragment) {
         const inner = fragment.toSQL ? String(fragment.toSQL()) : String(fragment);
-        text += ` OR (${inner})`;
-        built = null;
+        pushWhere("OR", `(${inner})`);
         return this;
       },
       andWhere(expr, op, value) {
-        if (typeof expr === "string" && op !== undefined) {
-          validateIdentifier(String(expr), "andWhere(column)");
-          assertSafeWhereOperator(op, "andWhere(operator)");
-          const paramIndex = whereParams.length + 1;
-          whereConditions.push(`${String(expr)} ${String(op)} ${getPlaceholder(paramIndex)}`);
-          whereParams.push(value);
-          text = `${text} AND ${String(expr)} ${String(op)} ${getPlaceholder(paramIndex)}`;
-          built = null;
-          return this;
-        }
-        if (Array.isArray(expr)) {
-          const [col, op2, val] = expr;
-          const colName = String(col);
-          validateIdentifier(colName, "andWhere(column)");
-          const operator = assertSafeWhereOperator(op2, "andWhere(operator)");
-          if (operator === "in" || operator === "not in") {
-            const values = Array.isArray(val) ? val : [val];
-            const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-            whereConditions.push(`${colName} ${operator.toUpperCase()} (${placeholders})`);
-            whereParams.push(...values);
-            text = `${text} AND ${colName} ${operator.toUpperCase()} (${placeholders})`;
-            built = null;
-          } else {
-            const paramIndex = whereParams.length + 1;
-            whereConditions.push(`${colName} ${operator} ${getPlaceholder(paramIndex)}`);
-            whereParams.push(val);
-            text = `${text} AND ${colName} ${operator} ${getPlaceholder(paramIndex)}`;
-            built = null;
-          }
-          return this;
-        }
-        if (expr && typeof expr === "object" && !("raw" in expr)) {
-          const keys = Object.keys(expr);
-          const conditions = [];
-          for (const key of keys) {
-            const value2 = expr[key];
-            if (Array.isArray(value2)) {
-              const placeholders = getPlaceholders(value2.length, whereParams.length + 1);
-              conditions.push(`${key} IN (${placeholders})`);
-              whereConditions.push(`${key} IN (${placeholders})`);
-              whereParams.push(...value2);
-            } else {
-              const paramIndex = whereParams.length + 1;
-              conditions.push(`${key} = ${getPlaceholder(paramIndex)}`);
-              whereConditions.push(`${key} = ${getPlaceholder(paramIndex)}`);
-              whereParams.push(value2);
-            }
-          }
-          if (conditions.length > 0) {
-            text = `${text} AND ${conditions.join(" AND ")}`;
-            built = null;
-          }
-          return this;
-        }
-        if (expr && typeof expr.raw !== "undefined") {
-          whereConditions.push(expr.raw);
-          text = `${text} AND ${expr.raw}`;
-          built = null;
-          return this;
-        }
-        return this;
+        return addBooleanWhere(this, "AND", "andWhere", expr, op, value);
       },
       orWhere(expr, op, value) {
-        if (typeof expr === "string" && op !== undefined) {
-          validateIdentifier(String(expr), "orWhere(column)");
-          assertSafeWhereOperator(op, "orWhere(operator)");
-          const paramIndex = whereParams.length + 1;
-          whereConditions.push(`OR ${String(expr)} ${String(op)} ${getPlaceholder(paramIndex)}`);
-          whereParams.push(value);
-          text = `${text} OR ${String(expr)} ${String(op)} ${getPlaceholder(paramIndex)}`;
-          built = null;
-          return this;
-        }
-        if (Array.isArray(expr)) {
-          const [col, op2, val] = expr;
-          const colName = String(col);
-          validateIdentifier(colName, "orWhere(column)");
-          const operator = assertSafeWhereOperator(op2, "orWhere(operator)");
-          if (operator === "in" || operator === "not in") {
-            const values = Array.isArray(val) ? val : [val];
-            const placeholders = getPlaceholders(values.length, whereParams.length + 1);
-            whereConditions.push(`OR ${colName} ${operator.toUpperCase()} (${placeholders})`);
-            whereParams.push(...values);
-            text = `${text} OR ${colName} ${operator.toUpperCase()} (${placeholders})`;
-            built = null;
-          } else {
-            const paramIndex = whereParams.length + 1;
-            whereConditions.push(`OR ${colName} ${operator} ${getPlaceholder(paramIndex)}`);
-            whereParams.push(val);
-            text = `${text} OR ${colName} ${operator} ${getPlaceholder(paramIndex)}`;
-            built = null;
-          }
-          return this;
-        }
-        if (expr && typeof expr === "object" && !("raw" in expr)) {
-          const keys = Object.keys(expr);
-          const conditions = [];
-          for (const key of keys) {
-            const value2 = expr[key];
-            if (Array.isArray(value2)) {
-              const placeholders = getPlaceholders(value2.length, whereParams.length + 1);
-              conditions.push(`${key} IN (${placeholders})`);
-              whereConditions.push(`OR ${key} IN (${placeholders})`);
-              whereParams.push(...value2);
-            } else {
-              const paramIndex = whereParams.length + 1;
-              conditions.push(`${key} = ${getPlaceholder(paramIndex)}`);
-              whereConditions.push(`OR ${key} = ${getPlaceholder(paramIndex)}`);
-              whereParams.push(value2);
-            }
-          }
-          if (conditions.length > 0) {
-            text = `${text} OR ${conditions.join(" AND ")}`;
-            built = null;
-          }
-          return this;
-        }
-        if (expr && typeof expr.raw !== "undefined") {
-          whereConditions.push(`OR ${expr.raw}`);
-          text = `${text} OR ${expr.raw}`;
-          built = null;
-          return this;
-        }
-        return this;
+        return addBooleanWhere(this, "OR", "orWhere", expr, op, value);
       },
       orderBy(column, direction = "asc") {
         const dir = direction === "asc" ? "ASC" : "DESC";
@@ -14854,7 +14814,7 @@ function createQueryBuilder(state) {
         return this;
       },
       toSQL() {
-        const sqlText = reorderSelectClauses(text);
+        const sqlText = reorderSelectClauses(currentSql());
         return {
           sql: sqlText,
           toString: () => sqlText,
@@ -14900,7 +14860,7 @@ function createQueryBuilder(state) {
         if (!Number.isFinite(page) || page < 1 || !Number.isInteger(page))
           throw new TypeError(`[query-builder] paginate(page): expected integer >= 1, got ${page}`);
         if (opts.tx) {
-          const baseSql = reorderSelectClauses(text);
+          const baseSql = reorderSelectClauses(currentSql());
           const baseParams = [...whereParams];
           const cRows2 = await opts.tx.unsafe(`SELECT COUNT(*) as c FROM (${baseSql}) as sub`, baseParams);
           const total2 = Number(cRows2?.[0]?.c ?? 0);
@@ -15020,8 +14980,8 @@ function createQueryBuilder(state) {
         };
         const predicate = `${table}.${softDeleteColumn} IS NOT NULL`;
         text = splice(text, predicate);
-        const currentSql = String(ensureBuilt());
-        built = sql([splice(currentSql, predicate)]);
+        const currentSql2 = String(ensureBuilt());
+        built = sql([splice(currentSql2, predicate)]);
         return this;
       },
       scope(name, value) {
@@ -15064,7 +15024,7 @@ function createQueryBuilder(state) {
         return ensureBuilt().simple();
       },
       toText() {
-        return text;
+        return currentSql();
       },
       async get() {
         const hooks = activeHooks();
@@ -15072,11 +15032,12 @@ function createQueryBuilder(state) {
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !hasQueryHooks) {
           const prepareFn = _sql._prepareStatement;
           if (prepareFn) {
-            const stmt = prepareFn(text);
+            const stmt = prepareFn(currentSql());
             return hydratePivotRows(whereParams.length > 0 ? stmt.all(...whereParams) : stmt.all());
           }
         }
-        built = whereParams.length > 0 ? _sql.unsafe(text, whereParams) : _sql.unsafe(text);
+        const getText = currentSql();
+        built = whereParams.length > 0 ? _sql.unsafe(getText, whereParams) : _sql.unsafe(getText);
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !hasQueryHooks) {
           const stmt = ensureBuilt()._stmt;
           const params = ensureBuilt()._params;
@@ -15093,9 +15054,9 @@ function createQueryBuilder(state) {
           const col = config5.softDeletes.column;
           const tbl = String(table);
           const hasCol = schema ? Boolean(schema[tbl]?.columns?.[col]) : true;
-          if (hasCol && !SQL_PATTERNS.DELETED_AT.test(text)) {
-            finalQuery = sql`${ensureBuilt()} WHERE ${sql(String(col))} IS ${onlyTrashed ? sql`NOT NULL` : sql`NULL`}`;
+          if (hasCol && !SQL_PATTERNS.DELETED_AT.test(currentSql())) {
             addWhereText("WHERE", `${String(col)} IS ${onlyTrashed ? "NOT " : ""}NULL`);
+            finalQuery = ensureBuilt();
           }
         }
         const cacheKey = useCache ? `${String(finalQuery)}\x00${JSON.stringify(whereParams)}` : "";
@@ -15125,7 +15086,8 @@ function createQueryBuilder(state) {
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !fHasQueryHooks) {
           const prepareFn = _sql._prepareStatement;
           if (prepareFn) {
-            const firstText = text.includes(" LIMIT ") ? text : `${text} LIMIT 1`;
+            const base2 = currentSql();
+            const firstText = base2.includes(" LIMIT ") ? base2 : `${base2} LIMIT 1`;
             const stmt = prepareFn(firstText);
             const rows2 = whereParams.length > 0 ? stmt.all(...whereParams) : stmt.all();
             return hydratePivotRow(rows2[0]);
@@ -15192,13 +15154,14 @@ function createQueryBuilder(state) {
         return fn(this);
       },
       async count() {
-        const fromIdx = text.indexOf(" FROM ");
-        const hasGroupBy = / GROUP BY /i.test(text);
+        const src = currentSql();
+        const fromIdx = src.indexOf(" FROM ");
+        const hasGroupBy = / GROUP BY /i.test(src);
         let countText;
         if (hasGroupBy) {
-          countText = `SELECT COUNT(*) as c FROM (${text}) AS _bqb_count_sub`;
+          countText = `SELECT COUNT(*) as c FROM (${src}) AS _bqb_count_sub`;
         } else if (fromIdx !== -1) {
-          countText = `SELECT COUNT(*) as c${text.substring(fromIdx)}`;
+          countText = `SELECT COUNT(*) as c${src.substring(fromIdx)}`;
         } else {
           countText = `SELECT COUNT(*) as c FROM ${table}`;
         }
@@ -15218,8 +15181,9 @@ function createQueryBuilder(state) {
         return Number(row?.c ?? 0);
       },
       async avg(column) {
-        const fromIdx = text.indexOf(" FROM ");
-        const avgText = fromIdx !== -1 ? `SELECT AVG(${column}) as a${text.substring(fromIdx)}` : `SELECT AVG(${column}) as a FROM ${table}`;
+        const src = currentSql();
+        const fromIdx = src.indexOf(" FROM ");
+        const avgText = fromIdx !== -1 ? `SELECT AVG(${column}) as a${src.substring(fromIdx)}` : `SELECT AVG(${column}) as a FROM ${table}`;
         const aHooks = activeHooks();
         const aHasHooks = aHooks && (aHooks.onQueryStart || aHooks.onQueryEnd || aHooks.onQueryError || aHooks.startSpan || hasSlowQueryHook(aHooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !aHasHooks) {
@@ -15236,24 +15200,27 @@ function createQueryBuilder(state) {
         return Number(row?.a ?? 0);
       },
       async sum(column) {
-        const fromIdx = text.indexOf(" FROM ");
-        const sumText = fromIdx !== -1 ? `SELECT SUM(${column}) as s${text.substring(fromIdx)}` : `SELECT SUM(${column}) as s FROM ${table}`;
+        const src = currentSql();
+        const fromIdx = src.indexOf(" FROM ");
+        const sumText = fromIdx !== -1 ? `SELECT SUM(${column}) as s${src.substring(fromIdx)}` : `SELECT SUM(${column}) as s FROM ${table}`;
         const q = whereParams.length > 0 ? _sql.unsafe(sumText, whereParams) : _sql.unsafe(sumText);
         const rows = await runWithHooks(q, "select", { signal: abortSignal, timeoutMs });
         const [row] = rows;
         return Number(row?.s ?? 0);
       },
       async max(column) {
-        const fromIdx = text.indexOf(" FROM ");
-        const maxText = fromIdx !== -1 ? `SELECT MAX(${column}) as m${text.substring(fromIdx)}` : `SELECT MAX(${column}) as m FROM ${table}`;
+        const src = currentSql();
+        const fromIdx = src.indexOf(" FROM ");
+        const maxText = fromIdx !== -1 ? `SELECT MAX(${column}) as m${src.substring(fromIdx)}` : `SELECT MAX(${column}) as m FROM ${table}`;
         const q = whereParams.length > 0 ? _sql.unsafe(maxText, whereParams) : _sql.unsafe(maxText);
         const rows = await runWithHooks(q, "select", { signal: abortSignal, timeoutMs });
         const [row] = rows;
         return row?.m;
       },
       async min(column) {
-        const fromIdx = text.indexOf(" FROM ");
-        const minText = fromIdx !== -1 ? `SELECT MIN(${column}) as m${text.substring(fromIdx)}` : `SELECT MIN(${column}) as m FROM ${table}`;
+        const src = currentSql();
+        const fromIdx = src.indexOf(" FROM ");
+        const minText = fromIdx !== -1 ? `SELECT MIN(${column}) as m${src.substring(fromIdx)}` : `SELECT MIN(${column}) as m FROM ${table}`;
         const q = whereParams.length > 0 ? _sql.unsafe(minText, whereParams) : _sql.unsafe(minText);
         const rows = await runWithHooks(q, "select", { signal: abortSignal, timeoutMs });
         const [row] = rows;
@@ -15292,7 +15259,7 @@ function createQueryBuilder(state) {
         return [...whereParams];
       },
       __rawState() {
-        return { sql: reorderSelectClauses(text), params: [...whereParams] };
+        return { sql: reorderSelectClauses(currentSql()), params: [...whereParams] };
       },
       raw() {
         return ensureBuilt().raw();
@@ -15336,8 +15303,6 @@ function createQueryBuilder(state) {
             return () => receiver;
           const column = chosen;
           return (value) => {
-            const expr = Array.isArray(value) ? sql`${sql(column)} IN ${sql(value)}` : sql`${sql(column)} = ${value}`;
-            built = isOr ? sql`${ensureBuilt()} OR ${expr}` : isAnd ? sql`${ensureBuilt()} AND ${expr}` : sql`${ensureBuilt()} WHERE ${expr}`;
             if (Array.isArray(value)) {
               const phs = getPlaceholders(value.length, whereParams.length + 1);
               addWhereText(isOr ? "OR" : isAnd ? "AND" : "WHERE", `${column} IN (${phs})`);
@@ -15392,8 +15357,7 @@ function createQueryBuilder(state) {
       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 appendWhere = (params, expr, op, value) => {
         const out = [...params];
         const cmp = (col, operator, val) => {
           validateIdentifier(col, "selectFromSub where(column)");
@@ -15409,61 +15373,91 @@ function createQueryBuilder(state) {
           return `${col} ${o} ${ph}`;
         };
         let clause;
-        if (typeof expr === "string" && op !== undefined)
+        if (typeof expr === "string" && op !== undefined) {
           clause = cmp(expr, op, value);
-        else if (Array.isArray(expr) && expr.length === 3)
+        } 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 };
+        } else if (expr && typeof expr === "object") {
+          const parts = Object.entries(expr).map(([k, v]) => cmp(k, "=", v));
+          clause = parts.length > 1 ? `(${parts.join(" AND ")})` : parts[0];
+        } else {
+          return { clause: null, params };
+        }
+        return { clause, params: out };
       };
-      function makeSub(text, params, hasWhere = false) {
+      function makeSub(baseText2, terms, params, tail = "") {
+        const body = renderWhereTerms(terms);
+        const text = body ? `${baseText2} WHERE ${body}${tail}` : `${baseText2}${tail}`;
         const build = () => params.length > 0 ? _sql.unsafe(text, params) : _sql.unsafe(text);
+        const withTerm = (conn, expr, op, value) => {
+          const r = appendWhere(params, expr, op, value);
+          return r.clause === null ? makeSub(baseText2, terms, params, tail) : makeSub(baseText2, [...terms, { conn, sql: r.clause }], r.params, tail);
+        };
+        const withGroup = (conn, cb) => {
+          const gTerms = [];
+          let gParams = [...params];
+          const add = (c) => (expr, op, value) => {
+            const r = appendWhere(gParams, expr, op, value);
+            if (r.clause !== null) {
+              gTerms.push({ conn: c, sql: r.clause });
+              gParams = r.params;
+            }
+            return collector;
+          };
+          const collector = { where: add("AND"), andWhere: add("AND"), orWhere: add("OR") };
+          cb(collector);
+          const body2 = renderWhereTerms(gTerms);
+          if (!body2) {
+            throw new TypeError("[query-builder] selectFromSub.whereGroup(callback): the callback added no conditions. " + "Add at least one where()/orWhere() to the builder it receives.");
+          }
+          return makeSub(baseText2, [...terms, { conn, sql: `(${body2})` }], gParams, tail);
+        };
         const base = {
           distinct() {
-            return makeSub(text.replace(/^SELECT\s+/i, "SELECT DISTINCT "), params, hasWhere);
+            return makeSub(baseText2.replace(/^SELECT\s+/i, "SELECT DISTINCT "), terms, params, tail);
           },
           distinctOn(...columns) {
             const cols = columns.map(String).join(", ");
-            return makeSub(text.replace(/^SELECT\s+/i, `SELECT DISTINCT ON (${cols}) `), params, hasWhere);
+            return makeSub(baseText2.replace(/^SELECT\s+/i, `SELECT DISTINCT ON (${cols}) `), terms, params, tail);
           },
           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);
+            const fromIdx = baseText2.indexOf(" FROM ");
+            const newBase = fromIdx !== -1 ? `${baseText2.slice(0, fromIdx)}, ${frag}${baseText2.slice(fromIdx)}` : `${baseText2}, ${frag}`;
+            return makeSub(newBase, terms, params, tail);
           },
           where(expr, op, value) {
-            const r = appendWhere(text, params, hasWhere, expr, op, value, "WHERE");
-            return makeSub(r.text, r.params, true);
+            return withTerm("AND", expr, op, value);
           },
           andWhere(expr, op, value) {
-            const r = appendWhere(text, params, hasWhere, expr, op, value, "AND");
-            return makeSub(r.text, r.params, true);
+            return withTerm("AND", expr, op, value);
           },
           orWhere(expr, op, value) {
-            const r = appendWhere(text, params, hasWhere, expr, op, value, "OR");
-            return makeSub(r.text, r.params, true);
+            return withTerm("OR", expr, op, value);
+          },
+          whereGroup(cb) {
+            return withGroup("AND", cb);
+          },
+          orWhereGroup(cb) {
+            return withGroup("OR", cb);
           },
           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);
+            const newTail = SQL_PATTERNS.ORDER_BY.test(tail) ? `${tail}, ${column} ${dir}` : `${tail} ORDER BY ${column} ${dir}`;
+            return makeSub(baseText2, terms, params, newTail);
           },
           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);
+            const newTail = SQL_PATTERNS.LIMIT.test(tail) ? tail.replace(SQL_PATTERNS.LIMIT, ` LIMIT ${n}`) : `${tail} LIMIT ${n}`;
+            return makeSub(baseText2, terms, params, newTail);
           },
           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);
+            const newTail = SQL_PATTERNS.OFFSET.test(tail) ? tail.replace(SQL_PATTERNS.OFFSET, ` OFFSET ${n}`) : `${tail} OFFSET ${n}`;
+            return makeSub(baseText2, terms, params, newTail);
           },
           toSQL() {
             return makeExecutableQuery(build(), text);
@@ -15546,8 +15540,13 @@ function createQueryBuilder(state) {
           whereJsonContains: subqueryNotSupported("whereJsonContains"),
           whereJsonPath: subqueryNotSupported("whereJsonPath"),
           whereNull: subqueryNotSupported("whereNull"),
+          orWhereNull: subqueryNotSupported("orWhereNull"),
           whereNotNull: subqueryNotSupported("whereNotNull"),
+          orWhereNotNull: subqueryNotSupported("orWhereNotNull"),
           whereExists: subqueryNotSupported("whereExists"),
+          orWhereExists: subqueryNotSupported("orWhereExists"),
+          orWhereBetween: subqueryNotSupported("orWhereBetween"),
+          orWhereRaw: subqueryNotSupported("orWhereRaw"),
           whereJsonDoesntContain: subqueryNotSupported("whereJsonDoesntContain"),
           whereJsonContainsKey: subqueryNotSupported("whereJsonContainsKey"),
           whereJsonDoesntContainKey: subqueryNotSupported("whereJsonDoesntContainKey"),
@@ -15626,7 +15625,7 @@ function createQueryBuilder(state) {
         };
         return base;
       }
-      return makeSub(baseText, subParams);
+      return makeSub(baseText, [], subParams);
     },
     insertInto(table) {
       let built;
@@ -16731,7 +16730,7 @@ function clearQueryCache() {
 function setQueryCacheMaxSize(size) {
   queryCache.setMaxSize(size);
 }
-var FALSE_PREDICATE = "1 = 0", TRUE_PREDICATE = "1 = 1", SQL_PATTERNS, SAFE_WHERE_OPERATORS, warnedSqlFragmentContexts, queryCache, reorderCache, REORDER_CACHE_MAX = 500;
+var SQL_PATTERNS, SAFE_WHERE_OPERATORS, warnedSqlFragmentContexts, queryCache, reorderCache, REORDER_CACHE_MAX = 500;
 var init_client = __esm(() => {
   init_config();
   init_db();
@@ -19466,7 +19465,7 @@ var init_migrate = __esm(() => {
   init_src2();
   init_introspect_db();
   init_workspace();
-  NON_TRANSACTIONAL_SQL = /\bCONCURRENTLY\b|^\s*VACUUM\b/im;
+  NON_TRANSACTIONAL_SQL = /\bCONCURRENTLY\b|^\s*VACUUM\b|^\s*BEGIN\s*(?:;|TRANSACTION\b)|^\s*PRAGMA\s+foreign_keys\b/im;
 });
 
 // src/actions/migrate-generate.ts
@@ -20525,6 +20524,135 @@ var init_actions = __esm(() => {
   init_wait_ready();
 });
 
+// src/faker-compat.ts
+function asStringOptions(value) {
+  if (typeof value === "number")
+    return { length: value };
+  return value;
+}
+function asNumberOptions(value) {
+  if (typeof value === "number")
+    return { max: value };
+  return value;
+}
+function callable(value) {
+  return typeof value === "function";
+}
+function flattened(name) {
+  return name.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
+}
+function withFractionDigits(value, options) {
+  if (!options || typeof options.fractionDigits !== "number")
+    return value;
+  return Number(value.toFixed(options.fractionDigits));
+}
+function compatModule(underlying, overrides = {}) {
+  if (!underlying)
+    return overrides;
+  return new Proxy(underlying, {
+    get(target, property) {
+      if (property in overrides)
+        return overrides[property];
+      const direct = target[property];
+      if (direct !== undefined)
+        return direct;
+      const fallback = target[flattened(property)];
+      if (callable(fallback))
+        return fallback.bind(target);
+      return;
+    }
+  });
+}
+function createFakerCompatLayer(underlying) {
+  const pick = (items) => {
+    const list = Array.isArray(items) ? items : [];
+    const index = Math.floor(Math.random() * list.length);
+    return list[index];
+  };
+  const strings = () => underlying.string;
+  const numbers = () => underlying.number;
+  const random = () => underlying.random;
+  const compatString = compatModule(underlying.string, {
+    alpha: (options) => strings()?.alpha?.(asStringOptions(options)),
+    alphanumeric: (options) => strings()?.alphanumeric?.(asStringOptions(options)),
+    numeric: (options) => strings()?.numeric?.(asStringOptions(options)),
+    sample: (options) => strings()?.sample?.(asStringOptions(options)),
+    hexadecimal: (options) => strings()?.hexadecimal?.(asStringOptions(options))
+  });
+  const compatNumber = compatModule(underlying.number, {
+    int: (options) => numbers()?.int?.(asNumberOptions(options)),
+    float: (options) => {
+      const parsed = asNumberOptions(options);
+      return withFractionDigits(Number(numbers()?.float?.(parsed) ?? 0), parsed);
+    }
+  });
+  const compatHelpers = compatModule(underlying.helpers, {
+    arrayElement: pick,
+    arrayElements: (items, count) => {
+      const list = [...Array.isArray(items) ? items : []];
+      const wanted = typeof count === "number" ? count : Math.max(1, Math.floor(Math.random() * list.length));
+      for (let at = list.length - 1;at > 0; at -= 1) {
+        const swap = Math.floor(Math.random() * (at + 1));
+        [list[at], list[swap]] = [list[swap], list[at]];
+      }
+      return list.slice(0, Math.min(wanted, list.length));
+    },
+    shuffle: (items) => {
+      const list = [...Array.isArray(items) ? items : []];
+      for (let at = list.length - 1;at > 0; at -= 1) {
+        const swap = Math.floor(Math.random() * (at + 1));
+        [list[at], list[swap]] = [list[swap], list[at]];
+      }
+      return list;
+    },
+    maybe: (produce, options) => {
+      const probability = typeof options?.probability === "number" ? options.probability : 0.5;
+      return Math.random() < probability ? produce() : undefined;
+    },
+    slugify: (text) => String(text ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")
+  });
+  const compatDatatype = {
+    boolean: (options) => {
+      const probability = typeof options === "number" ? options : options?.probability;
+      if (typeof probability === "number")
+        return Math.random() < probability;
+      return Boolean(random()?.boolean?.());
+    },
+    number: (options) => Number(numbers()?.int?.(asNumberOptions(options)) ?? 0),
+    float: (options) => withFractionDigits(Number(numbers()?.float?.(options) ?? 0), options),
+    uuid: () => crypto.randomUUID(),
+    string: (length) => String(strings()?.alphanumeric?.({ length: length ?? 10 }) ?? ""),
+    hexadecimal: (options) => String(strings()?.hexadecimal?.(asStringOptions(options)) ?? ""),
+    array: (length) => Array.from({ length: length ?? 3 }, () => strings()?.alphanumeric?.({ length: 8 })),
+    json: () => JSON.stringify({ value: strings()?.alphanumeric?.({ length: 8 }) })
+  };
+  const modules = {
+    string: compatString,
+    number: compatNumber,
+    helpers: compatHelpers,
+    datatype: compatDatatype,
+    location: compatModule(underlying.address),
+    address: compatModule(underlying.address),
+    vehicle: compatModule(underlying.vehicle, {
+      vrm: () => underlying.vehicle?.registration?.()
+    }),
+    company: compatModule(underlying.company, {
+      catchPhrase: () => underlying.company?.catchphrase?.(),
+      buzzPhrase: () => underlying.company?.bs?.() ?? underlying.company?.buzzword?.()
+    })
+  };
+  return new Proxy(underlying, {
+    get(target, property) {
+      if (property in modules)
+        return modules[property];
+      const direct = target[property];
+      if (direct && typeof direct === "object")
+        return compatModule(direct);
+      return direct;
+    }
+  });
+}
+
 // src/relation-utils.ts
 function normalizeRelationEntry(entry) {
   if (typeof entry === "string")
@@ -26232,9 +26360,8 @@ class ModelQueryBuilder {
     return this._withRelations;
   }
   buildWhereClauses(params) {
-    const clauses = [];
-    for (let i2 = 0;i2 < this._wheres.length; i2++) {
-      const w = this._wheres[i2];
+    const terms = [];
+    for (const w of this._wheres) {
       let clause;
       if (w.raw) {
         clause = w.raw;
@@ -26245,15 +26372,15 @@ class ModelQueryBuilder {
         clause = w.operator === "=" ? `${col} IS NULL` : `${col} IS NOT NULL`;
       } else if (w.operator === "in" || w.operator === "not in") {
         const arr = w.value;
-        clause = `${sqlColumn(w.column)} ${w.operator.toUpperCase()} (${arr.map(() => "?").join(", ")})`;
+        clause = renderInPredicate(sqlColumn(w.column), arr, w.operator === "not in", arr.map(() => "?").join(", "));
         params.push(...arr);
       } else {
         clause = `${sqlColumn(w.column)} ${w.operator} ?`;
         params.push(w.value);
       }
-      clauses.push(i2 === 0 ? clause : `${w.boolean.toUpperCase()} ${clause}`);
+      terms.push({ conn: w.boolean === "or" ? "OR" : "AND", sql: clause });
     }
-    return clauses.join(" ");
+    return renderWhereTerms(terms);
   }
   softDeleteClause() {
     if (this._trashed === "include" || !softDeletesEnabled(this._definition))
@@ -26845,27 +26972,6 @@ async function createTableFromModel(definition) {
   }
   await exec.run(`CREATE TABLE IF NOT EXISTS ${definition.table} (${columns.join(", ")})`, []);
 }
-function createFakerCompatLayer(underlying) {
-  return new Proxy(underlying, {
-    get(target, prop) {
-      if (prop === "location")
-        return target.address;
-      if (prop === "datatype") {
-        const rng = target.random;
-        const num = target.number;
-        const str = target.string;
-        return {
-          boolean: () => rng?.boolean?.(),
-          number: (opts) => num?.int?.(opts),
-          float: (opts) => num?.float?.(opts),
-          uuid: () => crypto.randomUUID(),
-          string: (length) => str?.alphanumeric?.(length ?? 10)
-        };
-      }
-      return target[prop];
-    }
-  });
-}
 async function seedModel(definition, count, faker) {
   const exec = getExecutor();
   const seeder = definition.traits?.useSeeder;
@@ -31874,7 +31980,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.2.27";
+var version2 = "0.2.29";
 
 // bin/cli.ts
 init_actions();