bun-query-builder 0.1.25 → 0.1.27

package/dist/bin/cli.js

@@ -11694,7 +11694,7 @@ function setConfig(userConfig) {
     Object.assign(_config, config5);
   }
 }
-var defaultConfig4, config5, _config = null, _lastConfiguredDialect = null, _warnedDialectConflicts;
+var defaultConfig4, CONFIG_SINGLETON_KEY, config5, _config = null, _lastConfiguredDialect = null, _warnedDialectConflicts;
 var init_config = __esm(() => {
   init_dist();
   defaultConfig4 = {
@@ -11754,7 +11754,8 @@ var init_config = __esm(() => {
       defaultFilter: true
     }
   };
-  config5 = { ...defaultConfig4 };
+  CONFIG_SINGLETON_KEY = Symbol.for("bun-query-builder.config");
+  config5 = globalThis[CONFIG_SINGLETON_KEY] ??= { ...defaultConfig4 };
   _warnedDialectConflicts = new Set;
 });
 
@@ -11975,6 +11976,16 @@ function createSQLiteSQL(filename) {
   return sqlFunction;
 }
 function createConnectionString(dialect, dbConfig) {
+  if ((dialect === "postgres" || dialect === "mysql") && process19.env.DB_CONNECTION === dialect) {
+    const e = process19.env;
+    const envDb = (e.DB_DATABASE || dbConfig.database || "").replace(/^['"]|['"]$/g, "");
+    const envUser = e.DB_USERNAME || dbConfig.username;
+    const envPass = e.DB_PASSWORD ?? dbConfig.password ?? "";
+    const envHost = e.DB_HOST || dbConfig.host || "localhost";
+    const envPort = e.DB_PORT || dbConfig.port;
+    const scheme = dialect === "postgres" ? "postgres" : "mysql";
+    return `${scheme}://${envUser}:${envPass}@${envHost}${envPort ? `:${envPort}` : ""}/${envDb}`;
+  }
   if (dbConfig.url) {
     return dbConfig.url;
   }
@@ -11993,6 +12004,21 @@ function createConnectionString(dialect, dbConfig) {
       throw new Error(`Unsupported dialect: ${dialect}`);
   }
 }
+function resolvePoolOptions(pool) {
+  if (!pool)
+    return {};
+  const out = {};
+  const toSeconds = (ms) => Math.max(0, Math.round(ms / 1000));
+  if (typeof pool.max === "number" && Number.isFinite(pool.max))
+    out.max = pool.max;
+  if (typeof pool.idleTimeoutMs === "number" && Number.isFinite(pool.idleTimeoutMs))
+    out.idleTimeout = toSeconds(pool.idleTimeoutMs);
+  if (typeof pool.acquireTimeoutMs === "number" && Number.isFinite(pool.acquireTimeoutMs))
+    out.connectionTimeout = toSeconds(pool.acquireTimeoutMs);
+  if (typeof pool.maxLifetimeMs === "number" && Number.isFinite(pool.maxLifetimeMs))
+    out.maxLifetime = toSeconds(pool.maxLifetimeMs);
+  return out;
+}
 function getBunSql() {
   const dialect = config5.dialect;
   const connectionString = createConnectionString(dialect, config5.database);
@@ -12000,14 +12026,8 @@ function getBunSql() {
     if (dialect === "sqlite") {
       return createSQLiteSQL(connectionString);
     }
-    const sql = new SQL(connectionString);
-    if (sql && typeof sql.catch === "function") {
-      sql.catch((error) => {
-        if (config5.verbose && !error.message.includes("database") && !error.message.includes("does not exist")) {
-          console.warn(`[query-builder] Database connection error: ${error.message}`);
-        }
-      });
-    }
+    const poolOptions = resolvePoolOptions(config5.database.pool);
+    const sql = Object.keys(poolOptions).length > 0 ? new SQL(connectionString, poolOptions) : new SQL(connectionString);
     return sql;
   } catch (error) {
     console.error(`[query-builder] Failed to create database connection for dialect '${dialect}': ${error.message}`);
@@ -12017,19 +12037,31 @@ function getBunSql() {
     throw error;
   }
 }
+function connectionSignature() {
+  const d = config5.database;
+  return JSON.stringify({
+    dialect: config5.dialect,
+    database: d.database,
+    username: d.username,
+    password: d.password,
+    host: d.host,
+    port: d.port,
+    url: d.url,
+    pool: resolvePoolOptions(d.pool)
+  });
+}
 function getOrCreateBunSql(forceNew = false) {
-  const configChanged = _bunSqlInstance !== null && (_currentDialect !== config5.dialect || _currentDatabase !== config5.database.database);
+  const signature = connectionSignature();
+  const configChanged = _bunSqlInstance !== null && _currentSignature !== signature;
   if (forceNew || configChanged || !_bunSqlInstance) {
     _bunSqlInstance = getBunSql();
-    _currentDialect = config5.dialect;
-    _currentDatabase = config5.database.database;
+    _currentSignature = signature;
   }
   return _bunSqlInstance;
 }
 function resetConnection() {
   _bunSqlInstance = null;
-  _currentDialect = null;
-  _currentDatabase = null;
+  _currentSignature = null;
 }
 async function withFreshConnection(fn) {
   try {
@@ -12044,7 +12076,7 @@ async function withFreshConnection(fn) {
   }
 }
 function createLazyBunSql() {
-  return new Proxy({}, {
+  return new Proxy(function lazyBunSql() {}, {
     get(_target, prop) {
       const sql = getOrCreateBunSql();
       const value = sql[prop];
@@ -12059,20 +12091,10 @@ function createLazyBunSql() {
     }
   });
 }
-var _bunSqlInstance = null, _currentDialect = null, _currentDatabase = null, bunSql;
+var _bunSqlInstance = null, _currentSignature = null, bunSql;
 var init_db = __esm(() => {
   init_config();
   bunSql = createLazyBunSql();
-  if (typeof process19 !== "undefined" && process19.on) {
-    const existingHandler = process19.listeners("unhandledRejection").find((h) => h.name === "sqlConnectionErrorHandler");
-    if (!existingHandler) {
-      let sqlConnectionErrorHandler = function(reason) {
-        if (reason && (reason.message?.includes("database") || reason.message?.includes("does not exist") || reason.code === "ERR_POSTGRES_SERVER_ERROR" || reason.code === "3D000")) {}
-      };
-      Object.defineProperty(sqlConnectionErrorHandler, "name", { value: "sqlConnectionErrorHandler" });
-      process19.on("unhandledRejection", sqlConnectionErrorHandler);
-    }
-  }
 });
 
 // src/actions/benchmark.ts
@@ -12322,6 +12344,47 @@ function* iterateAllPivots(meta, options = {}) {
 function isRawExpression(expr) {
   return typeof expr === "object" && expr !== null && "raw" in expr && typeof expr.raw === "string";
 }
+function quoteInsertIdent(id) {
+  return config5.dialect === "mysql" ? `\`${id.replace(/`/g, "``")}\`` : `"${id.replace(/"/g, '""')}"`;
+}
+function buildInsertClause(rows, startIndex = 1) {
+  const cols = Object.keys(rows[0] ?? {});
+  const params = [];
+  let idx = startIndex;
+  const tuples = rows.map((row) => {
+    const phs = cols.map((c) => {
+      params.push(row[c]);
+      return getPlaceholder(idx++);
+    });
+    return `(${phs.join(", ")})`;
+  });
+  return {
+    colsSql: cols.map(quoteInsertIdent).join(", "),
+    valuesSql: tuples.join(", "),
+    params,
+    nextIndex: idx
+  };
+}
+function hasSlowQueryHook(h) {
+  return Boolean(h && (h.onSlowQuery || h.slowQueryThresholdMs != null && h.slowQueryThresholdMs >= 0));
+}
+function renderSelectColumn(col) {
+  if (typeof col === "string")
+    return col;
+  if (isRawExpression(col))
+    return col.raw;
+  if (col && typeof col === "object") {
+    const anyCol = col;
+    if (typeof anyCol.raw === "function")
+      return String(anyCol.raw());
+    if (typeof anyCol.sql === "string")
+      return anyCol.sql;
+    const str = String(col);
+    if (str !== "[object Object]")
+      return str;
+  }
+  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 validateIdentifier(name, context) {
   if (!SQL_PATTERNS.IDENTIFIER.test(name)) {
     const contextMsg = context ? ` in ${context}` : "";
@@ -12340,13 +12403,29 @@ class QueryCache {
       this.cache.delete(key);
       return null;
     }
+    this.cache.delete(key);
+    this.cache.set(key, entry);
     return entry.data;
   }
   set(key, data, ttlMs) {
+    if (this.cache.has(key))
+      this.cache.delete(key);
     if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey)
-        this.cache.delete(firstKey);
+      const now = Date.now();
+      let evicted = false;
+      for (const [k, v] of this.cache) {
+        if (now > v.expiresAt) {
+          this.cache.delete(k);
+          evicted = true;
+          if (this.cache.size < this.maxSize)
+            break;
+        }
+      }
+      if (!evicted) {
+        const lruKey = this.cache.keys().next().value;
+        if (lruKey !== undefined)
+          this.cache.delete(lruKey);
+      }
     }
     this.cache.set(key, {
       data,
@@ -12417,6 +12496,9 @@ function reorderSelectClauses(sql) {
       continue;
     if (i === 0 || !/\s/.test(sql[i - 1]))
       continue;
+    const lead = sql.charCodeAt(i) & ~32;
+    if (lead !== 71 && lead !== 79 && lead !== 72 && lead !== 76 && lead !== 87)
+      continue;
     const rest = sql.slice(i);
     for (const { key, tokens } of KEYWORDS) {
       const m = rest.match(tokens);
@@ -12536,20 +12618,35 @@ function createQueryBuilder(state) {
       config5.debug.captureText = prev;
     return s;
   }
+  function computeParams(q) {
+    if (!q || typeof q !== "object")
+      return;
+    if (Array.isArray(q.values))
+      return q.values;
+    if (Array.isArray(q.parameters))
+      return q.parameters;
+    if (Array.isArray(q.params))
+      return q.params;
+    return;
+  }
   function runWithHooks(q, kind, opts) {
     const hooks = config5.hooks;
-    const hasHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan);
+    const slowMs = hooks?.slowQueryThresholdMs;
+    const slowEnabled = slowMs != null && slowMs >= 0;
+    const hasSlowQuery = Boolean(hooks?.onSlowQuery || slowEnabled);
+    const hasHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan || hasSlowQuery);
     const hasTimeoutOrSignal = opts?.timeoutMs && opts.timeoutMs > 0 || opts?.signal;
     if (!hasHooks && !hasTimeoutOrSignal) {
       return q.execute();
     }
     const text = computeSqlText(q);
+    const params = computeParams(q);
     const startAt = Date.now();
     let span;
     try {
-      hooks?.onQueryStart?.({ sql: text, kind });
+      hooks?.onQueryStart?.({ sql: text, params, kind });
       if (hooks?.startSpan)
-        span = hooks.startSpan({ sql: text, kind });
+        span = hooks.startSpan({ sql: text, params, kind });
     } catch {}
     let finished = false;
     const finish = (err, rowCount) => {
@@ -12559,9 +12656,15 @@ function createQueryBuilder(state) {
       const durationMs = Date.now() - startAt;
       try {
         if (err) {
-          hooks?.onQueryError?.({ sql: text, error: err, durationMs, kind });
+          hooks?.onQueryError?.({ sql: text, params, error: err, durationMs, kind });
         } else {
-          hooks?.onQueryEnd?.({ sql: text, durationMs, rowCount, kind });
+          hooks?.onQueryEnd?.({ sql: text, params, durationMs, rowCount, kind });
+          if (slowEnabled && durationMs >= slowMs) {
+            if (hooks?.onSlowQuery)
+              hooks.onSlowQuery({ sql: text, params, durationMs, kind });
+            else
+              console.warn(`[query-builder] slow query (${durationMs}ms >= ${slowMs}ms): ${text}`);
+          }
         }
       } catch {}
       try {
@@ -12641,6 +12744,36 @@ function createQueryBuilder(state) {
       const p = hasWhere ? prefix : "WHERE";
       text = `${text} ${p} ${clause}`;
     };
+    const appendSetOp = (op, other) => {
+      const st = other.__rawState?.();
+      if (st) {
+        const offset = whereParams.length;
+        const otherSql = config5.dialect === "postgres" ? st.sql.replace(/\$(\d+)/g, (_m, n) => `$${Number(n) + offset}`) : st.sql;
+        text += ` ${op} ${otherSql}`;
+        whereParams.push(...st.params);
+      } else {
+        text += ` ${op} ${String(other.toSQL())}`;
+      }
+      built = null;
+    };
+    const insertJoin = (joinClause) => {
+      const re = /\(|\)|\b(?:WHERE|GROUP BY|HAVING|ORDER BY|LIMIT|OFFSET|UNION)\b/gi;
+      let depth = 0;
+      let cut = -1;
+      let mm;
+      while (mm = re.exec(text)) {
+        if (mm[0] === "(") {
+          depth++;
+        } else if (mm[0] === ")") {
+          depth = Math.max(0, depth - 1);
+        } else if (depth === 0) {
+          cut = mm.index;
+          break;
+        }
+      }
+      text = cut >= 0 ? `${text.slice(0, cut)}${joinClause} ${text.slice(cut)}` : `${text} ${joinClause}`;
+      built = null;
+    };
     const joinedTables = new Set;
     let timeoutMs;
     let abortSignal;
@@ -12725,6 +12858,18 @@ function createQueryBuilder(state) {
         }
       }
     };
+    const buildOverClause = (partitionBy, orderBy) => {
+      const cols = Array.isArray(partitionBy) ? partitionBy : partitionBy ? [partitionBy] : [];
+      const parts = [];
+      if (cols.length)
+        parts.push(`PARTITION BY ${cols.join(", ")}`);
+      if (orderBy && orderBy.length)
+        parts.push(`ORDER BY ${orderBy.map(([c, d]) => `${c} ${d === "desc" ? "DESC" : "ASC"}`).join(", ")}`);
+      return parts.length ? `OVER (${parts.join(" ")})` : "OVER ()";
+    };
+    const addWindowFunction = (fnExpr, alias, partitionBy, orderBy) => {
+      addToSelectClause(`${fnExpr} ${buildOverClause(partitionBy, orderBy)} AS ${alias}`);
+    };
     function assertSafeWhereOperator(op, context) {
       if (typeof op !== "string")
         throw new TypeError(`[query-builder] ${context}: operator must be a string, got ${typeof op}`);
@@ -12864,6 +13009,46 @@ function createQueryBuilder(state) {
       validateIdentifier(fkA, "withCount (foreign key)");
       return `(SELECT COUNT(*) FROM ${pivot} WHERE ${pivot}.${fkA} = ${parentTable}.${pk})`;
     };
+    const applyRelationAggregate = (fn, relation, column) => {
+      if (!meta)
+        return;
+      validateIdentifier(column, `with${fn[0]}${fn.slice(1).toLowerCase()} (column)`);
+      const parentTable = String(table);
+      const rels = meta.relations?.[parentTable];
+      if (!rels)
+        return;
+      const found = Object.entries(rels).find(([_t, relMap2]) => relMap2 && typeof relMap2 === "object" && (relation in relMap2));
+      if (!found)
+        return;
+      const [type, relMap] = found;
+      const entry = relMap[relation];
+      const targetModel = typeof entry === "string" ? entry : entry?.model || entry?.target || entry;
+      const targetTable = meta.modelToTable[targetModel] || targetModel;
+      const pk = meta.primaryKeys[parentTable] ?? "id";
+      validateIdentifier(targetTable, `with${fn} (target table)`);
+      const aggExpr = `${fn}(${targetTable}.${column})`;
+      let sub;
+      if (type === "hasMany" || type === "hasOne") {
+        const fk = `${parentTable.endsWith("s") ? parentTable.slice(0, -1) : parentTable}_id`;
+        validateIdentifier(fk, `with${fn} (foreign key)`);
+        sub = `(SELECT ${aggExpr} FROM ${targetTable} WHERE ${targetTable}.${fk} = ${parentTable}.${pk})`;
+      } else if (type === "belongsToMany") {
+        const resolved = meta ? resolvePivot(meta, parentTable, relation, { singularize, models: meta.models }) : null;
+        const a = singularize(parentTable);
+        const b = singularize(targetTable);
+        const pivot = resolved?.pivotTable ?? [a, b].sort().join("_");
+        const fkA = resolved?.fkParent ?? `${a}_id`;
+        const fkB = resolved?.fkRelated ?? `${b}_id`;
+        const targetPk = meta.primaryKeys[targetTable] ?? "id";
+        validateIdentifier(pivot, `with${fn} (pivot table)`);
+        validateIdentifier(fkA, `with${fn} (foreign key)`);
+        validateIdentifier(fkB, `with${fn} (related key)`);
+        sub = `(SELECT ${aggExpr} FROM ${pivot} JOIN ${targetTable} ON ${targetTable}.${targetPk} = ${pivot}.${fkB} WHERE ${pivot}.${fkA} = ${parentTable}.${pk})`;
+      } else {
+        return;
+      }
+      addToSelectClause(`${sub} AS ${relation}_${fn.toLowerCase()}_${column}`);
+    };
     const applyPivotColumnsToQuery = () => {
       if (pivotColumns.size === 0)
         return;
@@ -12958,6 +13143,52 @@ function createQueryBuilder(state) {
         built = null;
         return this;
       },
+      over(expression, alias, opts = {}) {
+        addWindowFunction(expression, alias, opts.partitionBy, opts.orderBy);
+        return this;
+      },
+      lag(column, opts = {}) {
+        const args = [column, String(opts.offset ?? 1)];
+        if (opts.defaultValue !== undefined)
+          args.push(String(opts.defaultValue));
+        addWindowFunction(`LAG(${args.join(", ")})`, opts.alias ?? `${column}_lag`, opts.partitionBy, opts.orderBy);
+        return this;
+      },
+      lead(column, opts = {}) {
+        const args = [column, String(opts.offset ?? 1)];
+        if (opts.defaultValue !== undefined)
+          args.push(String(opts.defaultValue));
+        addWindowFunction(`LEAD(${args.join(", ")})`, opts.alias ?? `${column}_lead`, opts.partitionBy, opts.orderBy);
+        return this;
+      },
+      sumOver(column, opts = {}) {
+        addWindowFunction(`SUM(${column})`, opts.alias ?? `${column}_sum`, opts.partitionBy, opts.orderBy);
+        return this;
+      },
+      avgOver(column, opts = {}) {
+        addWindowFunction(`AVG(${column})`, opts.alias ?? `${column}_avg`, opts.partitionBy, opts.orderBy);
+        return this;
+      },
+      countOver(column = "*", opts = {}) {
+        addWindowFunction(`COUNT(${column})`, opts.alias ?? "count_over", opts.partitionBy, opts.orderBy);
+        return this;
+      },
+      minOver(column, opts = {}) {
+        addWindowFunction(`MIN(${column})`, opts.alias ?? `${column}_min`, opts.partitionBy, opts.orderBy);
+        return this;
+      },
+      maxOver(column, opts = {}) {
+        addWindowFunction(`MAX(${column})`, opts.alias ?? `${column}_max`, opts.partitionBy, opts.orderBy);
+        return this;
+      },
+      firstValue(column, opts = {}) {
+        addWindowFunction(`FIRST_VALUE(${column})`, opts.alias ?? `${column}_first`, opts.partitionBy, opts.orderBy);
+        return this;
+      },
+      lastValue(column, opts = {}) {
+        addWindowFunction(`LAST_VALUE(${column})`, opts.alias ?? `${column}_last`, opts.partitionBy, opts.orderBy);
+        return this;
+      },
       selectAll() {
         return this;
       },
@@ -12967,22 +13198,24 @@ function createQueryBuilder(state) {
         const cols = Array.isArray(columns2) ? columns2 : [columns2];
         if (cols.length === 0)
           return this;
+        const rendered = cols.map(renderSelectColumn);
         const fromIndex = text.indexOf(" FROM ");
         if (fromIndex !== -1) {
-          text = `SELECT ${cols.join(", ")}${text.substring(fromIndex)}`;
+          text = `SELECT ${rendered.join(", ")}${text.substring(fromIndex)}`;
         } else {
-          text = `SELECT ${cols.join(", ")} FROM ${table}`;
+          text = `SELECT ${rendered.join(", ")} FROM ${table}`;
         }
         return this;
       },
       addSelect(...columns2) {
         if (!columns2.length)
           return this;
+        const rendered = columns2.map(renderSelectColumn);
         const fromIdx = text.indexOf(" FROM ");
         if (fromIdx !== -1) {
-          text = `${text.substring(0, fromIdx)}, ${columns2.join(", ")}${text.substring(fromIdx)}`;
+          text = `${text.substring(0, fromIdx)}, ${rendered.join(", ")}${text.substring(fromIdx)}`;
         } else {
-          text += `, ${columns2.join(", ")}`;
+          text += `, ${rendered.join(", ")}`;
         }
         built = null;
         return this;
@@ -13042,28 +13275,6 @@ function createQueryBuilder(state) {
           if (!rels) {
             return fromTable;
           }
-          const _buildConditionalJoin = (baseJoinCondition, targetTable2) => {
-            let joinCondition = baseJoinCondition;
-            if (config5.softDeletes?.enabled && config5.softDeletes?.defaultFilter) {
-              const softDeleteColumn = config5.softDeletes.column || "deleted_at";
-              joinCondition = `${joinCondition} AND ${targetTable2}.${softDeleteColumn} IS NULL`;
-            }
-            if (!condition)
-              return joinCondition;
-            const conditionBuilder = {
-              where: (col, op, val) => {
-                const valStr = typeof val === "string" ? `'${val}'` : String(val);
-                return `${targetTable2}.${col} ${op} ${valStr}`;
-              }
-            };
-            try {
-              const additionalCondition = condition(conditionBuilder);
-              if (additionalCondition && typeof additionalCondition === "string") {
-                return `${joinCondition} AND ${additionalCondition}`;
-              }
-            } catch {}
-            return joinCondition;
-          };
           const addSoftDeleteCheck = (table2) => {
             if (config5.softDeletes?.enabled && config5.softDeletes?.defaultFilter) {
               const softDeleteColumn = config5.softDeletes.column || "deleted_at";
@@ -13399,6 +13610,22 @@ function createQueryBuilder(state) {
         }
         return this;
       },
+      withSum(relation, column) {
+        applyRelationAggregate("SUM", relation, column);
+        return this;
+      },
+      withAvg(relation, column) {
+        applyRelationAggregate("AVG", relation, column);
+        return this;
+      },
+      withMax(relation, column) {
+        applyRelationAggregate("MAX", relation, column);
+        return this;
+      },
+      withMin(relation, column) {
+        applyRelationAggregate("MIN", relation, column);
+        return this;
+      },
       applyPivotColumns() {
         applyPivotColumnsToQuery();
         return this;
@@ -13526,6 +13753,8 @@ function createQueryBuilder(state) {
       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)");
           const operator = String(op).toLowerCase();
           if (operator === "in" || operator === "not in") {
             const values = Array.isArray(value) ? value : [value];
@@ -13547,7 +13776,8 @@ function createQueryBuilder(state) {
         if (Array.isArray(expr)) {
           const [col, op2, val] = expr;
           const colName = String(col);
-          const operator = String(op2);
+          validateIdentifier(colName, "where(column)");
+          const operator = assertSafeWhereOperator(op2, "where(operator)");
           if (operator === "in" || operator === "not in") {
             const values = Array.isArray(val) ? val : [val];
             const placeholders = getPlaceholders(values.length, whereParams.length + 1);
@@ -13569,6 +13799,7 @@ function createQueryBuilder(state) {
           const keys = Object.keys(whereObject);
           const conditions = [];
           for (const key of keys) {
+            validateIdentifier(key, "where(column)");
             const value2 = whereObject[key];
             if (Array.isArray(value2)) {
               const placeholders = getPlaceholders(value2.length, whereParams.length + 1);
@@ -13597,21 +13828,25 @@ function createQueryBuilder(state) {
         return this;
       },
       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;
         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;
         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);
-        text = `${text} ${keyword} ${String(column)} BETWEEN ? AND ?`;
         built = null;
         return this;
       },
@@ -13622,10 +13857,32 @@ function createQueryBuilder(state) {
         return this;
       },
       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;
-        text += ` ${keyword} ${column} @> ${getPlaceholder(idx)}`;
-        whereParams.push(JSON.stringify(json));
+        if (dialect === "postgres") {
+          if (config5.sql?.jsonContainsMode === "function")
+            text += ` ${keyword} jsonb_contains(${column}, ${getPlaceholder(idx)})`;
+          else
+            text += ` ${keyword} ${column} @> ${getPlaceholder(idx)}`;
+          whereParams.push(JSON.stringify(json));
+        } else if (dialect === "mysql") {
+          text += ` ${keyword} 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 ")})`;
+            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)})`;
+            whereParams.push(json);
+          }
+        }
         built = null;
         return this;
       },
@@ -13652,69 +13909,85 @@ function createQueryBuilder(state) {
       whereLike(column, pattern, caseSensitive = false) {
         const expr = caseSensitive ? sql`${sql(String(column))} LIKE ${pattern}` : sql`LOWER(${sql(String(column))}) LIKE LOWER(${pattern})`;
         built = sql`${ensureBuilt()} WHERE ${expr}`;
-        addWhereText("WHERE", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} LIKE ${caseSensitive ? "?" : "LOWER(?)"}`);
+        const ph = getPlaceholder(whereParams.length + 1);
+        addWhereText("WHERE", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} LIKE ${caseSensitive ? ph : `LOWER(${ph})`}`);
+        whereParams.push(pattern);
         return this;
       },
       whereILike(column, pattern) {
+        const ph = getPlaceholder(whereParams.length + 1);
         if (config5.dialect === "postgres") {
           built = sql`${ensureBuilt()} WHERE ${sql(String(column))} ILIKE ${pattern}`;
-          addWhereText("WHERE", `${String(column)} ILIKE ?`);
+          addWhereText("WHERE", `${String(column)} ILIKE ${ph}`);
         } else {
           const expr = sql`LOWER(${sql(String(column))}) LIKE LOWER(${pattern})`;
           built = sql`${ensureBuilt()} WHERE ${expr}`;
-          addWhereText("WHERE", `LOWER(${String(column)}) LIKE LOWER(?)`);
+          addWhereText("WHERE", `LOWER(${String(column)}) LIKE LOWER(${ph})`);
         }
+        whereParams.push(pattern);
         return this;
       },
       orWhereLike(column, pattern, caseSensitive = false) {
         const expr = caseSensitive ? sql`${sql(String(column))} LIKE ${pattern}` : sql`LOWER(${sql(String(column))}) LIKE LOWER(${pattern})`;
         built = sql`${ensureBuilt()} OR ${expr}`;
-        addWhereText("OR", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} LIKE ${caseSensitive ? "?" : "LOWER(?)"}`);
+        const ph = getPlaceholder(whereParams.length + 1);
+        addWhereText("OR", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} LIKE ${caseSensitive ? ph : `LOWER(${ph})`}`);
+        whereParams.push(pattern);
         return this;
       },
       orWhereILike(column, pattern) {
+        const ph = getPlaceholder(whereParams.length + 1);
         if (config5.dialect === "postgres") {
           built = sql`${ensureBuilt()} OR ${sql(String(column))} ILIKE ${pattern}`;
-          addWhereText("OR", `${String(column)} ILIKE ?`);
+          addWhereText("OR", `${String(column)} ILIKE ${ph}`);
         } else {
           const expr = sql`LOWER(${sql(String(column))}) LIKE LOWER(${pattern})`;
           built = sql`${ensureBuilt()} OR ${expr}`;
-          addWhereText("OR", `LOWER(${String(column)}) LIKE LOWER(?)`);
+          addWhereText("OR", `LOWER(${String(column)}) LIKE LOWER(${ph})`);
         }
+        whereParams.push(pattern);
         return this;
       },
       whereNotLike(column, pattern, caseSensitive = false) {
         const expr = caseSensitive ? sql`${sql(String(column))} NOT LIKE ${pattern}` : sql`LOWER(${sql(String(column))}) NOT LIKE LOWER(${pattern})`;
         built = sql`${ensureBuilt()} WHERE ${expr}`;
-        addWhereText("WHERE", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} NOT LIKE ${caseSensitive ? "?" : "LOWER(?)"}`);
+        const ph = getPlaceholder(whereParams.length + 1);
+        addWhereText("WHERE", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} NOT LIKE ${caseSensitive ? ph : `LOWER(${ph})`}`);
+        whereParams.push(pattern);
         return this;
       },
       whereNotILike(column, pattern) {
+        const ph = getPlaceholder(whereParams.length + 1);
         if (config5.dialect === "postgres") {
           built = sql`${ensureBuilt()} WHERE ${sql(String(column))} NOT ILIKE ${pattern}`;
-          addWhereText("WHERE", `${String(column)} NOT ILIKE ?`);
+          addWhereText("WHERE", `${String(column)} NOT ILIKE ${ph}`);
         } else {
           const expr = sql`LOWER(${sql(String(column))}) NOT LIKE LOWER(${pattern})`;
           built = sql`${ensureBuilt()} WHERE ${expr}`;
-          addWhereText("WHERE", `LOWER(${String(column)}) NOT LIKE LOWER(?)`);
+          addWhereText("WHERE", `LOWER(${String(column)}) NOT LIKE LOWER(${ph})`);
         }
+        whereParams.push(pattern);
         return this;
       },
       orWhereNotLike(column, pattern, caseSensitive = false) {
         const expr = caseSensitive ? sql`${sql(String(column))} NOT LIKE ${pattern}` : sql`LOWER(${sql(String(column))}) NOT LIKE LOWER(${pattern})`;
         built = sql`${ensureBuilt()} OR ${expr}`;
-        addWhereText("OR", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} NOT LIKE ${caseSensitive ? "?" : "LOWER(?)"}`);
+        const ph = getPlaceholder(whereParams.length + 1);
+        addWhereText("OR", `${caseSensitive ? String(column) : `LOWER(${String(column)})`} NOT LIKE ${caseSensitive ? ph : `LOWER(${ph})`}`);
+        whereParams.push(pattern);
         return this;
       },
       orWhereNotILike(column, pattern) {
+        const ph = getPlaceholder(whereParams.length + 1);
         if (config5.dialect === "postgres") {
           built = sql`${ensureBuilt()} OR ${sql(String(column))} NOT ILIKE ${pattern}`;
-          addWhereText("OR", `${String(column)} NOT ILIKE ?`);
+          addWhereText("OR", `${String(column)} NOT ILIKE ${ph}`);
         } else {
           const expr = sql`LOWER(${sql(String(column))}) NOT LIKE LOWER(${pattern})`;
           built = sql`${ensureBuilt()} OR ${expr}`;
-          addWhereText("OR", `LOWER(${String(column)}) NOT LIKE LOWER(?)`);
+          addWhereText("OR", `LOWER(${String(column)}) NOT LIKE LOWER(${ph})`);
         }
+        whereParams.push(pattern);
         return this;
       },
       whereAny(cols, op, value) {
@@ -13754,8 +14027,10 @@ function createQueryBuilder(state) {
         return this;
       },
       whereNotBetween(column, start, end) {
+        validateIdentifier(String(column), "whereNotBetween(column)");
         const keyword = SQL_PATTERNS.WHERE.test(text) ? "AND" : "WHERE";
-        text += ` ${keyword} ${column} NOT BETWEEN ? AND ?`;
+        const i = whereParams.length + 1;
+        text += ` ${keyword} ${column} NOT BETWEEN ${getPlaceholder(i)} AND ${getPlaceholder(i + 1)}`;
         whereParams.push(start, end);
         built = null;
         return this;
@@ -13795,6 +14070,7 @@ function createQueryBuilder(state) {
         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);
@@ -13807,6 +14083,7 @@ function createQueryBuilder(state) {
         return this;
       },
       orWhereIn(column, values) {
+        validateIdentifier(String(column), "orWhereIn(column)");
         if (Array.isArray(values)) {
           const placeholders = getPlaceholders(values.length, whereParams.length + 1);
           text += ` OR ${column} IN (${placeholders})`;
@@ -13818,6 +14095,7 @@ function createQueryBuilder(state) {
         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);
@@ -13830,6 +14108,7 @@ function createQueryBuilder(state) {
         return this;
       },
       orWhereNotIn(column, values) {
+        validateIdentifier(String(column), "orWhereNotIn(column)");
         if (Array.isArray(values)) {
           const placeholders = getPlaceholders(values.length, whereParams.length + 1);
           text += ` OR ${column} NOT IN (${placeholders})`;
@@ -13855,6 +14134,8 @@ function createQueryBuilder(state) {
       },
       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);
@@ -13865,7 +14146,8 @@ function createQueryBuilder(state) {
         if (Array.isArray(expr)) {
           const [col, op2, val] = expr;
           const colName = String(col);
-          const operator = String(op2);
+          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);
@@ -13915,6 +14197,8 @@ function createQueryBuilder(state) {
       },
       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);
@@ -13925,7 +14209,8 @@ function createQueryBuilder(state) {
         if (Array.isArray(expr)) {
           const [col, op2, val] = expr;
           const colName = String(col);
-          const operator = String(op2);
+          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);
@@ -14023,7 +14308,11 @@ function createQueryBuilder(state) {
         return this;
       },
       join(table2, onLeft, operator, onRight) {
-        text = `${text} JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`;
+        validateIdentifier(table2, "join(table)");
+        validateQualifiedIdentifier(onLeft, "join(onLeft)");
+        validateQualifiedIdentifier(onRight, "join(onRight)");
+        assertSafeWhereOperator(operator, "join(operator)");
+        insertJoin(`JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`);
         joinedTables.add(table2);
         return this;
       },
@@ -14032,44 +14321,55 @@ function createQueryBuilder(state) {
         validateQualifiedIdentifier(onLeft, "joinSub(onLeft)");
         validateQualifiedIdentifier(onRight, "joinSub(onRight)");
         assertSafeWhereOperator(operator, "joinSub(operator)");
-        text += ` JOIN (${String(sub.toSQL())}) AS ${alias} ON ${onLeft} ${operator} ${onRight}`;
-        built = null;
+        insertJoin(`JOIN (${String(sub.toSQL())}) AS ${alias} ON ${onLeft} ${operator} ${onRight}`);
         joinedTables.add(alias);
         return this;
       },
       innerJoin(table2, onLeft, operator, onRight) {
-        text = `${text} INNER JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`;
-        built = null;
+        validateIdentifier(table2, "innerJoin(table)");
+        validateQualifiedIdentifier(onLeft, "innerJoin(onLeft)");
+        validateQualifiedIdentifier(onRight, "innerJoin(onRight)");
+        assertSafeWhereOperator(operator, "innerJoin(operator)");
+        insertJoin(`INNER JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`);
         joinedTables.add(table2);
         return this;
       },
       leftJoin(table2, onLeft, operator, onRight) {
-        text = `${text} LEFT JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`;
-        built = null;
+        validateIdentifier(table2, "leftJoin(table)");
+        validateQualifiedIdentifier(onLeft, "leftJoin(onLeft)");
+        validateQualifiedIdentifier(onRight, "leftJoin(onRight)");
+        assertSafeWhereOperator(operator, "leftJoin(operator)");
+        insertJoin(`LEFT JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`);
         joinedTables.add(table2);
         return this;
       },
       leftJoinSub(sub, alias, onLeft, operator, onRight) {
-        text += ` LEFT JOIN (${String(sub.toSQL())}) AS ${alias} ON ${onLeft} ${operator} ${onRight}`;
-        built = null;
+        validateIdentifier(alias, "leftJoinSub(alias)");
+        validateQualifiedIdentifier(onLeft, "leftJoinSub(onLeft)");
+        validateQualifiedIdentifier(onRight, "leftJoinSub(onRight)");
+        assertSafeWhereOperator(operator, "leftJoinSub(operator)");
+        insertJoin(`LEFT JOIN (${String(sub.toSQL())}) AS ${alias} ON ${onLeft} ${operator} ${onRight}`);
         joinedTables.add(alias);
         return this;
       },
       rightJoin(table2, onLeft, operator, onRight) {
-        text = `${text} RIGHT JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`;
-        built = null;
+        validateIdentifier(table2, "rightJoin(table)");
+        validateQualifiedIdentifier(onLeft, "rightJoin(onLeft)");
+        validateQualifiedIdentifier(onRight, "rightJoin(onRight)");
+        assertSafeWhereOperator(operator, "rightJoin(operator)");
+        insertJoin(`RIGHT JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`);
         joinedTables.add(table2);
         return this;
       },
       crossJoin(table2) {
-        text = `${text} CROSS JOIN ${table2}`;
-        built = null;
+        validateIdentifier(table2, "crossJoin(table)");
+        insertJoin(`CROSS JOIN ${table2}`);
         joinedTables.add(table2);
         return this;
       },
       crossJoinSub(sub, alias) {
-        text += ` CROSS JOIN (${String(sub.toSQL())}) AS ${alias}`;
-        built = null;
+        validateIdentifier(alias, "crossJoinSub(alias)");
+        insertJoin(`CROSS JOIN (${String(sub.toSQL())}) AS ${alias}`);
         joinedTables.add(alias);
         return this;
       },
@@ -14122,9 +14422,10 @@ function createQueryBuilder(state) {
         return this;
       },
       having(expr) {
+        const kw = /\bHAVING\b/i.test(text) ? "AND" : "HAVING";
         if (Array.isArray(expr)) {
           const paramIdx = whereParams.length + 1;
-          text = `${text} HAVING ${expr[0]} ${expr[1]} ${getPlaceholder(paramIdx)}`;
+          text = `${text} ${kw} ${expr[0]} ${expr[1]} ${getPlaceholder(paramIdx)}`;
           whereParams.push(expr[2]);
           built = null;
         } else if (expr && typeof expr === "object" && !("raw" in expr)) {
@@ -14138,18 +14439,19 @@ function createQueryBuilder(state) {
               conditions[i] = `${key} = ${getPlaceholder(baseIdx + i + 1)}`;
               whereParams.push(expr[key]);
             }
-            text = `${text} HAVING ${conditions.join(" AND ")}`;
+            text = `${text} ${kw} ${conditions.join(" AND ")}`;
             built = null;
           }
         } else if (expr && typeof expr.raw !== "undefined") {
-          text += ` HAVING ${expr.raw}`;
+          text += ` ${kw} ${expr.raw}`;
           built = null;
         }
         return this;
       },
       havingRaw(fragment) {
         assertSqlFragment(fragment, "havingRaw(fragment)");
-        text += ` HAVING ${String(fragment)}`;
+        const kw = /\bHAVING\b/i.test(text) ? "AND" : "HAVING";
+        text += ` ${kw} ${String(fragment)}`;
         built = null;
         return this;
       },
@@ -14160,13 +14462,27 @@ function createQueryBuilder(state) {
         return this;
       },
       union(other) {
-        text += ` UNION ${String(other.toSQL())}`;
-        built = null;
+        appendSetOp("UNION", other);
         return this;
       },
       unionAll(other) {
-        text += ` UNION ALL ${String(other.toSQL())}`;
-        built = null;
+        appendSetOp("UNION ALL", other);
+        return this;
+      },
+      intersect(other) {
+        appendSetOp("INTERSECT", other);
+        return this;
+      },
+      intersectAll(other) {
+        appendSetOp("INTERSECT ALL", other);
+        return this;
+      },
+      except(other) {
+        appendSetOp("EXCEPT", other);
+        return this;
+      },
+      exceptAll(other) {
+        appendSetOp("EXCEPT ALL", other);
         return this;
       },
       forPage(page, perPage) {
@@ -14210,11 +14526,22 @@ function createQueryBuilder(state) {
         const e = await this.exists();
         return !e;
       },
-      async paginate(perPage, page = 1) {
+      async paginate(perPage, page = 1, opts = {}) {
         if (!Number.isFinite(perPage) || perPage <= 0 || !Number.isInteger(perPage))
           throw new TypeError(`[query-builder] paginate(perPage): expected positive integer, got ${perPage}`);
         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 baseParams = [...whereParams];
+          const cRows2 = await opts.tx.unsafe(`SELECT COUNT(*) as c FROM (${baseSql}) as sub`, baseParams);
+          const total2 = Number(cRows2?.[0]?.c ?? 0);
+          const lastPage2 = Math.max(1, Math.ceil(total2 / perPage));
+          const p2 = Math.max(1, Math.min(page, lastPage2));
+          const offset2 = (p2 - 1) * perPage;
+          const data2 = await opts.tx.unsafe(`${baseSql} LIMIT ${perPage} OFFSET ${offset2}`, baseParams);
+          return { data: data2, meta: { perPage, page: p2, total: total2, lastPage: lastPage2 } };
+        }
         const countQ = sql`SELECT COUNT(*) as c FROM (${ensureBuilt()}) as sub`;
         const cRows = await runWithHooks(countQ, "select", { signal: abortSignal, timeoutMs });
         const [cRow] = cRows;
@@ -14371,7 +14698,7 @@ function createQueryBuilder(state) {
       },
       async get() {
         const hooks = config5.hooks;
-        const hasQueryHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan);
+        const hasQueryHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan || hasSlowQueryHook(hooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !hasQueryHooks) {
           const prepareFn = _sql._prepareStatement;
           if (prepareFn) {
@@ -14426,7 +14753,7 @@ function createQueryBuilder(state) {
       },
       async first() {
         const fHooks = config5.hooks;
-        const fHasQueryHooks = fHooks && (fHooks.onQueryStart || fHooks.onQueryEnd || fHooks.onQueryError || fHooks.startSpan);
+        const fHasQueryHooks = fHooks && (fHooks.onQueryStart || fHooks.onQueryEnd || fHooks.onQueryError || fHooks.startSpan || hasSlowQueryHook(fHooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !fHasQueryHooks) {
           const prepareFn = _sql._prepareStatement;
           if (prepareFn) {
@@ -14508,7 +14835,7 @@ function createQueryBuilder(state) {
           countText = `SELECT COUNT(*) as c FROM ${table}`;
         }
         const cHooks = config5.hooks;
-        const cHasHooks = cHooks && (cHooks.onQueryStart || cHooks.onQueryEnd || cHooks.onQueryError || cHooks.startSpan);
+        const cHasHooks = cHooks && (cHooks.onQueryStart || cHooks.onQueryEnd || cHooks.onQueryError || cHooks.startSpan || hasSlowQueryHook(cHooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !cHasHooks) {
           const prepareFn = _sql._prepareStatement;
           if (prepareFn) {
@@ -14526,7 +14853,7 @@ function createQueryBuilder(state) {
         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 aHooks = config5.hooks;
-        const aHasHooks = aHooks && (aHooks.onQueryStart || aHooks.onQueryEnd || aHooks.onQueryError || aHooks.startSpan);
+        const aHasHooks = aHooks && (aHooks.onQueryStart || aHooks.onQueryEnd || aHooks.onQueryError || aHooks.startSpan || hasSlowQueryHook(aHooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !aHasHooks) {
           const prepareFn = _sql._prepareStatement;
           if (prepareFn) {
@@ -14596,6 +14923,9 @@ function createQueryBuilder(state) {
       toParams() {
         return ensureBuilt().values?.() ?? [];
       },
+      __rawState() {
+        return { sql: reorderSelectClauses(text), params: [...whereParams] };
+      },
       raw() {
         return ensureBuilt().raw();
       },
@@ -14954,15 +15284,15 @@ function createQueryBuilder(state) {
           params.length = totalParams;
           if (rowCount === 1) {
             if (!isPostgres) {
-              let cols = keys[0];
+              let cols = quoteId(keys[0]);
               let placeholders = "?";
               params[0] = firstRow[keys[0]];
               for (let c = 1;c < colCount; c++) {
-                cols += `,${keys[c]}`;
+                cols += `,${quoteId(keys[c])}`;
                 placeholders += ",?";
                 params[c] = firstRow[keys[c]];
               }
-              sqlText = `INSERT INTO ${table}(${cols})VALUES(${placeholders})`;
+              sqlText = `INSERT INTO ${quoteId(table)}(${cols})VALUES(${placeholders})`;
             } else {
               const columnList = keys.map((k) => quoteId(k)).join(",");
               sqlText = `INSERT INTO ${quoteId(table)}(${columnList})VALUES(`;
@@ -15020,7 +15350,7 @@ function createQueryBuilder(state) {
         },
         execute() {
           const hooks = config5.hooks;
-          const hasHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan || hooks.beforeCreate || hooks.afterCreate);
+          const hasHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan || hooks.beforeCreate || hooks.afterCreate || hasSlowQueryHook(hooks));
           if (!hasHooks) {
             const prepareFn = _sql._prepareStatement;
             if (prepareFn) {
@@ -15494,55 +15824,72 @@ function createQueryBuilder(state) {
       };
     },
     async insertOrIgnore(table, values) {
-      if (config5.dialect === "mysql") {
-        const built2 = bunSql`INSERT IGNORE INTO ${bunSql(String(table))} ${bunSql(values)}`;
-        return built2.execute();
-      }
-      const built = bunSql`INSERT INTO ${bunSql(String(table))} ${bunSql(values)} ON CONFLICT DO NOTHING`;
-      return built.execute();
+      const rows = Array.isArray(values) ? values : [values];
+      if (!rows.length)
+        return;
+      const { colsSql, valuesSql, params } = buildInsertClause(rows);
+      const tbl = quoteInsertIdent(String(table));
+      const sqlText = config5.dialect === "mysql" ? `INSERT IGNORE INTO ${tbl} (${colsSql}) VALUES ${valuesSql}` : `INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql} ON CONFLICT DO NOTHING`;
+      return bunSql.unsafe(sqlText, params).execute();
     },
     async insertGetId(table, values, idColumn = "id") {
+      const { colsSql, valuesSql, params } = buildInsertClause([values]);
+      const tbl = quoteInsertIdent(String(table));
       if (config5.dialect === "mysql") {
-        const insertQuery = bunSql`INSERT INTO ${bunSql(String(table))} ${bunSql(values)}`;
-        const result = await insertQuery.execute();
-        if (result && typeof result === "object" && "insertId" in result) {
-          return result.insertId;
-        }
-        const [lastIdResult] = await bunSql`SELECT LAST_INSERT_ID() as id`.execute();
-        return lastIdResult?.id;
-      } else {
-        const q = bunSql`INSERT INTO ${bunSql(String(table))} ${bunSql(values)} RETURNING ${bunSql(String(idColumn))} as id`;
-        const [row] = await q.execute();
-        return row?.id;
-      }
+        await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+        const [row2] = await bunSql.unsafe(`SELECT LAST_INSERT_ID() as id`).execute();
+        return row2?.id;
+      }
+      if (config5.dialect === "sqlite") {
+        const res = await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+        if (res?.lastInsertRowid != null)
+          return res.lastInsertRowid;
+        const [row2] = await bunSql.unsafe(`SELECT last_insert_rowid() as id`).execute();
+        return row2?.id;
+      }
+      const [row] = await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql} RETURNING ${quoteInsertIdent(String(idColumn))} as id`, params).execute();
+      return row?.id;
     },
     async updateOrInsert(table, match, values) {
-      const whereParts = Object.keys(match).map((k) => bunSql`${bunSql(String(k))} = ${bunSql(match[k])}`);
-      const existsQ = bunSql`SELECT 1 FROM ${bunSql(String(table))} WHERE ${bunSql(whereParts)} LIMIT 1`;
-      const existsRows = await existsQ.execute();
+      const tbl = quoteInsertIdent(String(table));
+      const matchKeys = Object.keys(match);
+      let idx = 1;
+      const whereSql = matchKeys.map((k) => `${quoteInsertIdent(k)} = ${getPlaceholder(idx++)}`).join(" AND ");
+      const whereParams = matchKeys.map((k) => match[k]);
+      const existsRows = await bunSql.unsafe(`SELECT 1 FROM ${tbl} WHERE ${whereSql} LIMIT 1`, whereParams).execute();
       if (existsRows.length) {
-        const upd = bunSql`UPDATE ${bunSql(String(table))} SET ${bunSql(values)} WHERE ${bunSql(whereParts)}`;
-        await upd.execute();
-        return true;
-      } else {
-        const ins = bunSql`INSERT INTO ${bunSql(String(table))} ${bunSql({ ...match, ...values })}`;
-        await ins.execute();
+        const setKeys = Object.keys(values);
+        let i = 1;
+        const setSql = setKeys.map((k) => `${quoteInsertIdent(k)} = ${getPlaceholder(i++)}`).join(", ");
+        const whereSql2 = matchKeys.map((k) => `${quoteInsertIdent(k)} = ${getPlaceholder(i++)}`).join(" AND ");
+        const params2 = [...setKeys.map((k) => values[k]), ...matchKeys.map((k) => match[k])];
+        await bunSql.unsafe(`UPDATE ${tbl} SET ${setSql} WHERE ${whereSql2}`, params2).execute();
         return true;
       }
+      const { colsSql, valuesSql, params } = buildInsertClause([{ ...match, ...values }]);
+      await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+      return true;
     },
     async upsert(table, rows, conflictColumns, mergeColumns) {
       const targetCols = conflictColumns.map((c) => String(c));
       const setCols = (mergeColumns ?? []).map((c) => String(c));
+      const list = rows;
+      if (!list.length)
+        return;
+      const { colsSql, valuesSql, params } = buildInsertClause(list);
+      const tbl = quoteInsertIdent(String(table));
+      const insert = `INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`;
       if (config5.dialect === "mysql") {
-        const updateList2 = setCols.map((c) => `\`${c.replace(/`/g, "``")}\` = VALUES(\`${c.replace(/`/g, "``")}\`)`).join(", ");
-        const built2 = bunSql`INSERT INTO ${bunSql(String(table))} ${bunSql(rows)} ON DUPLICATE KEY UPDATE ${bunSql.unsafe(updateList2)}`;
-        return built2.execute();
-      }
-      const isPostgres = config5.dialect === "postgres";
-      const quoteCol = (column) => isPostgres ? `"${column.replace(/"/g, '""')}"` : `"${column.replace(/"/g, '""')}"`;
-      const updateList = setCols.map((column) => `${quoteCol(column)} = EXCLUDED.${quoteCol(column)}`).join(", ");
-      const built = bunSql`INSERT INTO ${bunSql(String(table))} ${bunSql(rows)} ON CONFLICT (${bunSql(targetCols)}) DO UPDATE SET ${bunSql.unsafe(updateList)}`;
-      return built.execute();
+        if (setCols.length === 0)
+          return bunSql.unsafe(`INSERT IGNORE INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+        const updateList2 = setCols.map((c) => `${quoteInsertIdent(c)} = VALUES(${quoteInsertIdent(c)})`).join(", ");
+        return bunSql.unsafe(`${insert} ON DUPLICATE KEY UPDATE ${updateList2}`, params).execute();
+      }
+      const targets = targetCols.map(quoteInsertIdent).join(", ");
+      if (setCols.length === 0)
+        return bunSql.unsafe(`${insert} ON CONFLICT (${targets}) DO NOTHING`, params).execute();
+      const updateList = setCols.map((c) => `${quoteInsertIdent(c)} = EXCLUDED.${quoteInsertIdent(c)}`).join(", ");
+      return bunSql.unsafe(`${insert} ON CONFLICT (${targets}) DO UPDATE SET ${updateList}`, params).execute();
     },
     async save(table, values) {
       const pk = meta?.primaryKeys[String(table)] ?? "id";
@@ -15645,7 +15992,8 @@ function createQueryBuilder(state) {
       const colCount = keys.length;
       const rowCount = rows.length;
       const params = Array.from({ length: rowCount * colCount });
-      let sql = `INSERT INTO ${table}(${keys.join(",")})VALUES`;
+      const quoteId = config5.dialect === "mysql" ? (id) => `\`${String(id).replace(/`/g, "``")}\`` : (id) => `"${String(id).replace(/"/g, '""')}"`;
+      let sql = `INSERT INTO ${quoteId(String(table))}(${keys.map(quoteId).join(",")})VALUES`;
       let pidx = 0;
       for (let r = 0;r < rowCount; r++) {
         if (r > 0)
@@ -16865,6 +17213,126 @@ var init_introspect = __esm(() => {
   init_src2();
 });
 
+// src/actions/introspect-db.ts
+function sqlTypeToAttr(sqlType) {
+  const t = sqlType.toLowerCase();
+  if (/^bool|boolean|tinyint\(1\)/.test(t))
+    return "boolean";
+  if (/int|serial|numeric|decimal|double|real|float|money/.test(t))
+    return "number";
+  if (/timestamp|datetime|date|time/.test(t))
+    return "datetime";
+  if (/json/.test(t))
+    return "json";
+  return "string";
+}
+function singularize(name) {
+  if (/ies$/i.test(name))
+    return name.replace(/ies$/i, "y");
+  if (/ses$/i.test(name))
+    return name.replace(/es$/i, "");
+  if (/s$/i.test(name) && !/ss$/i.test(name))
+    return name.replace(/s$/i, "");
+  return name;
+}
+function pascalCase(name) {
+  return name.replace(/[-_\s]+/g, " ").split(" ").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function modelNameForTable(table) {
+  return pascalCase(singularize(table));
+}
+async function listTables(qb, dialect) {
+  if (dialect === "postgres") {
+    const rows2 = await qb.unsafe(`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE' ORDER BY table_name`);
+    return rows2.map((r) => r.table_name);
+  }
+  if (dialect === "mysql") {
+    const rows2 = await qb.unsafe(`SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE' ORDER BY table_name`);
+    return rows2.map((r) => r.table_name ?? r.TABLE_NAME);
+  }
+  const rows = await qb.unsafe(`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
+  return rows.map((r) => r.name);
+}
+async function readColumns(qb, dialect, table) {
+  if (dialect === "sqlite") {
+    const rows2 = await qb.unsafe(`PRAGMA table_info(${table})`);
+    return rows2.map((r) => ({
+      name: r.name,
+      sqlType: String(r.type || ""),
+      nullable: Number(r.notnull) === 0,
+      isPrimaryKey: Number(r.pk) > 0
+    }));
+  }
+  if (dialect === "postgres") {
+    const rows2 = await qb.unsafe(`SELECT c.column_name, c.data_type, c.is_nullable,
+         (SELECT COUNT(*) FROM information_schema.table_constraints tc
+            JOIN information_schema.key_column_usage k ON k.constraint_name = tc.constraint_name
+          WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_name = c.table_name AND k.column_name = c.column_name) AS is_pk
+       FROM information_schema.columns c
+       WHERE c.table_name = $1 AND c.table_schema = 'public'
+       ORDER BY c.ordinal_position`, [table]);
+    return rows2.map((r) => ({
+      name: r.column_name,
+      sqlType: String(r.data_type || ""),
+      nullable: String(r.is_nullable).toUpperCase() === "YES",
+      isPrimaryKey: Number(r.is_pk) > 0
+    }));
+  }
+  const rows = await qb.unsafe(`SELECT column_name, data_type, is_nullable, column_key
+     FROM information_schema.columns
+     WHERE table_name = ? AND table_schema = DATABASE()
+     ORDER BY ordinal_position`, [table]);
+  return rows.map((r) => ({
+    name: r.column_name ?? r.COLUMN_NAME,
+    sqlType: String(r.data_type ?? r.DATA_TYPE ?? ""),
+    nullable: String(r.is_nullable ?? r.IS_NULLABLE).toUpperCase() === "YES",
+    isPrimaryKey: String(r.column_key ?? r.COLUMN_KEY).toUpperCase() === "PRI"
+  }));
+}
+function generateModelSource(table, columns) {
+  const modelName = modelNameForTable(table);
+  const pk = columns.find((c) => c.isPrimaryKey)?.name ?? "id";
+  const attrLines = columns.map((c) => {
+    const parts = [`type: '${sqlTypeToAttr(c.sqlType)}'`];
+    if (!c.nullable && !c.isPrimaryKey)
+      parts.push("required: true");
+    return `      ${c.name}: { ${parts.join(", ")} },`;
+  }).join(`
+`);
+  return `export const ${modelName} = defineModel({
+  name: '${modelName}',
+  table: '${table}',
+  primaryKey: '${pk}',
+  attributes: {
+${attrLines}
+  },
+})
+`;
+}
+async function introspectDatabase(opts = {}) {
+  const dialect = config5.dialect || "postgres";
+  const qb = createQueryBuilder();
+  const tables = opts.tables?.length ? opts.tables : await listTables(qb, dialect);
+  const out = [];
+  for (const table of tables) {
+    const columns = await readColumns(qb, dialect, table);
+    if (!columns.length)
+      continue;
+    out.push({
+      table,
+      modelName: modelNameForTable(table),
+      primaryKey: columns.find((c) => c.isPrimaryKey)?.name ?? "id",
+      columns,
+      source: generateModelSource(table, columns)
+    });
+  }
+  return out;
+}
+var init_introspect_db = __esm(() => {
+  init_config();
+  init_src2();
+});
+
 // src/actions/make-model.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync5, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname5, join as join7 } from "path";
@@ -17807,9 +18275,51 @@ var init_migrate_generate = __esm(() => {
 });
 
 // src/actions/migrate-rollback.ts
-import { existsSync as existsSync17, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
 import { dirname as dirname7, join as join10 } from "path";
 import process26 from "process";
+function splitSqlStatements2(sql) {
+  const out = [];
+  let buf = "";
+  let inString = false;
+  const lines = sql.split(`
+`).filter((l) => !/^\s*--/.test(l));
+  const text = lines.join(`
+`);
+  for (let i = 0;i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "'")
+      inString = !inString;
+    if (ch === ";" && !inString) {
+      if (buf.trim())
+        out.push(buf.trim());
+      buf = "";
+    } else {
+      buf += ch;
+    }
+  }
+  if (buf.trim())
+    out.push(buf.trim());
+  return out;
+}
+function deriveDownStatements(forwardSql, dialect = config5.dialect) {
+  const q = (id) => dialect === "mysql" ? `\`${id}\`` : `"${id}"`;
+  const down = [];
+  const skipped = [];
+  for (const stmt of splitSqlStatements2(forwardSql)) {
+    let m;
+    if (m = /^CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`']?(\w+)["`']?/i.exec(stmt)) {
+      down.push(`DROP TABLE IF EXISTS ${q(m[1])}`);
+    } else if (m = /^ALTER\s+TABLE\s+["`']?(\w+)["`']?\s+ADD\s+(?:COLUMN\s+)?["`']?(\w+)["`']?/i.exec(stmt)) {
+      down.push(`ALTER TABLE ${q(m[1])} DROP COLUMN ${q(m[2])}`);
+    } else if (m = /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?["`']?(\w+)["`']?(?:\s+ON\s+["`']?(\w+)["`']?)?/i.exec(stmt)) {
+      down.push(dialect === "mysql" && m[2] ? `DROP INDEX ${q(m[1])} ON ${q(m[2])}` : `DROP INDEX IF EXISTS ${q(m[1])}`);
+    } else {
+      skipped.push(stmt);
+    }
+  }
+  return { down: down.reverse(), skipped };
+}
 function findWorkspaceRoot2(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname7(currentPath)) {
@@ -17828,6 +18338,7 @@ function getSqlDirectory2(workspaceRoot) {
 }
 async function migrateRollback(options = {}) {
   const steps = options.steps || 1;
+  const reverseSchema = options.reverseSchema !== false;
   console.log("-- Rolling back migrations");
   console.log(`-- Steps: ${steps}`);
   console.log();
@@ -17857,13 +18368,25 @@ async function migrateRollback(options = {}) {
       console.log(`  - ${migration.migration}`);
     }
     console.log();
+    const sqlDir = getSqlDirectory2();
+    let reversedAny = false;
     for (const migration of migrationsToRollback) {
       try {
+        const filePath = join10(sqlDir, migration.migration);
+        if (reverseSchema && existsSync17(filePath)) {
+          const forwardSql = readFileSync4(filePath, "utf8");
+          const { down, skipped } = deriveDownStatements(forwardSql);
+          for (const stmt of down) {
+            await qb.unsafe(stmt);
+            console.log(`-- \u21A9  ${stmt}`);
+            reversedAny = true;
+          }
+          if (skipped.length > 0)
+            console.log(`-- \u26A0\uFE0F  ${skipped.length} statement(s) in ${migration.migration} could not be auto-reversed (data/complex DDL) \u2014 reverse manually.`);
+        }
         const deleteSql = `DELETE FROM migrations WHERE migration = $1`;
         await qb.unsafe(deleteSql, [migration.migration]);
         console.log(`-- \u2713 Removed migration record: ${migration.migration}`);
-        const sqlDir = getSqlDirectory2();
-        const filePath = join10(sqlDir, migration.migration);
         if (existsSync17(filePath)) {
           unlinkSync2(filePath);
           console.log(`-- \uD83D\uDDD1\uFE0F  Deleted migration file: ${migration.migration}`);
@@ -17874,17 +18397,18 @@ async function migrateRollback(options = {}) {
       }
     }
     console.log();
-    console.log("-- \u26A0\uFE0F  Important: Rollback only removes migration records.");
-    console.log("-- To reverse schema changes:");
-    console.log("--   1. Revert your model changes");
-    console.log("--   2. Run `qb migrate:fresh` to rebuild the database");
-    console.log("--   or manually write and execute reverse SQL");
+    if (reverseSchema) {
+      console.log(reversedAny ? "-- \u2713 Reverse DDL executed for the rolled-back migration(s)." : "-- \u26A0\uFE0F  No reversible DDL found; only migration records were removed.");
+    } else {
+      console.log("-- \u26A0\uFE0F  reverseSchema disabled: only migration records were removed.");
+    }
   } catch (err) {
     console.error("-- Rollback failed:", err);
     throw err;
   }
 }
 var init_migrate_rollback = __esm(() => {
+  init_config();
   init_src2();
 });
 
@@ -18119,7 +18643,7 @@ var init_ping = __esm(() => {
 });
 
 // src/actions/query-explain-all.ts
-import { readdirSync as readdirSync10, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync10, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
 import { extname as extname3, join as join13 } from "path";
 async function queryExplainAll(path, options = {}) {
   const results = [];
@@ -18145,7 +18669,7 @@ async function queryExplainAll(path, options = {}) {
     }
     for (const file2 of files) {
       try {
-        const query = readFileSync4(file2, "utf8").trim();
+        const query = readFileSync5(file2, "utf8").trim();
         if (!query) {
           if (options.verbose) {
             console.log(`\u2298 ${file2}: empty file`);
@@ -18182,7 +18706,7 @@ async function queryExplainAll(path, options = {}) {
       } catch (error) {
         results.push({
           file: file2,
-          query: readFileSync4(file2, "utf8").trim(),
+          query: readFileSync5(file2, "utf8").trim(),
           plan: [],
           error: error.message
         });
@@ -18796,6 +19320,7 @@ var init_actions = __esm(() => {
   init_file();
   init_inspect();
   init_introspect();
+  init_introspect_db();
   init_make_model();
   init_migrate();
   init_migrate_generate();
@@ -23415,6 +23940,14 @@ function getDatabase() {
     return exec.sqliteDb;
   throw new Error(`[bun-query-builder] getDatabase() is only available for the sqlite dialect; ` + `the configured dialect is '${exec.dialect}'. Use the async model API instead.`);
 }
+function softDeletesEnabled(definition) {
+  const t2 = definition.traits;
+  return Boolean(t2?.useSoftDeletes || t2?.softDeletable);
+}
+function timestampsEnabled(definition) {
+  const t2 = definition.traits;
+  return Boolean(t2?.useTimestamps || t2?.timestampable);
+}
 function collectBelongsToManyKeys(definition) {
   const keys = new Set;
   const rel = definition.belongsToMany;
@@ -23584,7 +24117,7 @@ class ModelInstance {
       if (changeKeys.length > 0) {
         const sets = changeKeys.map((k2) => `${k2} = ?`).join(", ");
         const values = [...Object.values(changes), this._attributes[pk]];
-        if (this._definition.traits?.useTimestamps) {
+        if (timestampsEnabled(this._definition)) {
           const now = formatNow();
           await exec.run(`UPDATE ${this._definition.table} SET ${sets}, updated_at = ? WHERE ${pk} = ?`, [...Object.values(changes), now, this._attributes[pk]]);
         } else {
@@ -23596,11 +24129,13 @@ class ModelInstance {
       const attrs = this._definition.attributes;
       const data = {};
       for (const [key, attr] of Object.entries(attrs)) {
-        if (attr.fillable && this._attributes[key] !== undefined) {
+        if (attr.guarded)
+          continue;
+        if (this._attributes[key] !== undefined) {
           data[key] = this._attributes[key];
         }
       }
-      if (this._definition.traits?.useTimestamps) {
+      if (timestampsEnabled(this._definition)) {
         const now = formatNow();
         data.created_at = now;
         data.updated_at = now;
@@ -23646,14 +24181,31 @@ class ModelInstance {
     if (!pkValue)
       throw new Error("Cannot delete a model without a primary key");
     await hooks?.beforeDelete?.(this);
-    if (this._definition.traits?.useSoftDeletes) {
-      await exec.run(`UPDATE ${this._definition.table} SET deleted_at = ? WHERE ${pk} = ?`, [formatNow(), pkValue]);
+    if (softDeletesEnabled(this._definition)) {
+      const now = formatNow();
+      await exec.run(`UPDATE ${this._definition.table} SET deleted_at = ? WHERE ${pk} = ?`, [now, pkValue]);
+      this._attributes[SOFT_DELETE_COLUMN] = now;
     } else {
       await exec.run(`DELETE FROM ${this._definition.table} WHERE ${pk} = ?`, [pkValue]);
     }
     await hooks?.afterDelete?.(this);
     return true;
   }
+  async restore() {
+    if (!softDeletesEnabled(this._definition))
+      throw new Error(`[orm] restore() requires soft deletes on '${this._definition.name}'`);
+    const pk = this._definition.primaryKey || "id";
+    const pkValue = this._attributes[pk];
+    if (!pkValue)
+      throw new Error("Cannot restore a model without a primary key");
+    await getExecutor().run(`UPDATE ${this._definition.table} SET ${SOFT_DELETE_COLUMN} = ? WHERE ${pk} = ?`, [null, pkValue]);
+    this._attributes[SOFT_DELETE_COLUMN] = null;
+    this._original = null;
+    return this;
+  }
+  trashed() {
+    return this._attributes[SOFT_DELETE_COLUMN] != null;
+  }
   async refresh() {
     const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
@@ -23958,9 +24510,23 @@ class BelongsToManyRelationBuilder {
     this._offset = n2;
     return this;
   }
+  relatedSelectColumns() {
+    const cols = new Set([this.relatedPk, ...Object.keys(this._relatedDef.attributes ?? {})]);
+    const t2 = this._relatedDef.traits;
+    if (t2?.useTimestamps || t2?.timestampable) {
+      cols.add("created_at");
+      cols.add("updated_at");
+    }
+    if (t2?.useSoftDeletes || t2?.softDeletable)
+      cols.add("deleted_at");
+    if (t2?.useUuid)
+      cols.add("uuid");
+    return [...cols];
+  }
   buildSelect() {
     const params = [];
-    let sql2 = `SELECT ${this.relatedTable}.*, ${this.pivotTable}.* FROM ${this.relatedTable}`;
+    const relatedSelect = this.relatedSelectColumns().map((c2) => `${this.relatedTable}.${c2} AS ${BTM_RELATED_ALIAS}${c2}`).join(", ");
+    let sql2 = `SELECT ${relatedSelect}, ${this.pivotTable}.* FROM ${this.relatedTable}`;
     sql2 += ` INNER JOIN ${this.pivotTable} ON ${this.pivotTable}.${this.fkRelated} = ${this.relatedTable}.${this.relatedPk}`;
     sql2 += ` WHERE ${this.pivotTable}.${this.fkParent} = ?`;
     params.push(this.parentId);
@@ -23981,25 +24547,17 @@ class BelongsToManyRelationBuilder {
     return { sql: sql2, params };
   }
   hydrateRows(rows) {
-    const relatedAttrs = new Set(Object.keys(this._relatedDef.attributes ?? {}));
-    relatedAttrs.add(this.relatedPk);
-    relatedAttrs.add("created_at");
-    relatedAttrs.add("updated_at");
-    relatedAttrs.add("deleted_at");
     const fkParent = this.fkParent;
     const fkRelated = this.fkRelated;
     return rows.map((raw) => {
       const relatedRow = {};
       const pivotExtras = {};
       for (const [k2, v2] of Object.entries(raw)) {
-        if (k2 === fkParent || k2 === fkRelated)
-          continue;
-        if (relatedAttrs.has(k2))
-          relatedRow[k2] = v2;
-        else
+        if (k2.startsWith(BTM_RELATED_ALIAS))
+          relatedRow[k2.slice(BTM_RELATED_ALIAS.length)] = v2;
+        else if (k2 !== fkParent && k2 !== fkRelated)
           pivotExtras[k2] = v2;
       }
-      relatedRow[this.relatedPk] = raw[this.relatedPk];
       const inst = new ModelInstance(this._relatedDef, relatedRow);
       inst.pivot = pivotExtras;
       return inst;
@@ -24146,9 +24704,18 @@ class ModelQueryBuilder {
   _offset;
   _select = ["*"];
   _withRelations = [];
+  _trashed = "exclude";
   constructor(definition) {
     this._definition = definition;
   }
+  withTrashed() {
+    this._trashed = "include";
+    return this;
+  }
+  onlyTrashed() {
+    this._trashed = "only";
+    return this;
+  }
   where(column, operatorOrValue, value) {
     if (value === undefined) {
       this._wheres.push({ column, operator: "=", value: operatorOrValue, boolean: "and" });
@@ -24326,11 +24893,24 @@ class ModelQueryBuilder {
     }
     return clauses.join(" ");
   }
+  softDeleteClause() {
+    if (this._trashed === "include" || !softDeletesEnabled(this._definition))
+      return "";
+    return this._trashed === "only" ? `${SOFT_DELETE_COLUMN} IS NOT NULL` : `${SOFT_DELETE_COLUMN} IS NULL`;
+  }
+  composeWhere(params) {
+    const userClause = this._wheres.length > 0 ? this.buildWhereClauses(params) : "";
+    const sd = this.softDeleteClause();
+    if (userClause && sd)
+      return `(${userClause}) AND ${sd}`;
+    return userClause || sd;
+  }
   buildQuery() {
     const params = [];
     let sql2 = `SELECT ${this._select.join(", ")} FROM ${this._definition.table}`;
-    if (this._wheres.length > 0) {
-      sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
+    const whereBody = this.composeWhere(params);
+    if (whereBody) {
+      sql2 += ` WHERE ${whereBody}`;
     }
     if (this._orderBy.length > 0) {
       sql2 += ` ORDER BY ${this._orderBy.map((o2) => `${o2.column} ${o2.direction.toUpperCase()}`).join(", ")}`;
@@ -24354,6 +24934,8 @@ class ModelQueryBuilder {
       let rel = relationCache.get(cacheKey);
       if (rel === undefined) {
         rel = resolveRelation(this._definition, relationName);
+        if (relationCache.size >= RELATION_CACHE_MAX)
+          relationCache.clear();
         relationCache.set(cacheKey, rel);
       }
       if (!rel)
@@ -24390,8 +24972,13 @@ class ModelQueryBuilder {
         }
       }
       if (rel.type === "belongsTo") {
-        const fkValues = instances.map((i2) => i2._attributes[rel.foreignKey]).filter((v2) => v2 != null);
-        const uniqueFkValues = [...new Set(fkValues)];
+        const fkSet = new Set;
+        for (const i2 of instances) {
+          const v2 = i2._attributes[rel.foreignKey];
+          if (v2 != null)
+            fkSet.add(v2);
+        }
+        const uniqueFkValues = [...fkSet];
         if (uniqueFkValues.length === 0)
           continue;
         const placeholders = uniqueFkValues.map(() => "?").join(", ");
@@ -24421,7 +25008,13 @@ class ModelQueryBuilder {
             instance.setRelation(relationName, []);
           continue;
         }
-        const relatedIds = [...new Set(pivotRows.map((p2) => p2[rel.pivotFkRelated]))].filter((v2) => v2 != null);
+        const relatedIdSet = new Set;
+        for (const p2 of pivotRows) {
+          const v2 = p2[rel.pivotFkRelated];
+          if (v2 != null)
+            relatedIdSet.add(v2);
+        }
+        const relatedIds = [...relatedIdSet];
         const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
         const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
         const relatedPk = relDef?.primaryKey || "id";
@@ -24492,8 +25085,9 @@ class ModelQueryBuilder {
     const exec = getExecutor();
     const params = [];
     let sql2 = `SELECT COUNT(*) as count FROM ${this._definition.table}`;
-    if (this._wheres.length > 0) {
-      sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
+    const whereBody = this.composeWhere(params);
+    if (whereBody) {
+      sql2 += ` WHERE ${whereBody}`;
     }
     const row = await exec.get(sql2, params);
     return Number(row?.count ?? 0);
@@ -24518,7 +25112,7 @@ class ModelQueryBuilder {
     const exec = getExecutor();
     const params = [amount];
     let sql2 = `UPDATE ${this._definition.table} SET ${column} = ${column} + ?`;
-    if (this._definition.traits?.useTimestamps) {
+    if (timestampsEnabled(this._definition)) {
       sql2 += `, updated_at = ?`;
       params.push(formatNow());
     }
@@ -24539,6 +25133,7 @@ class ModelQueryBuilder {
       builder._orderBy = [...this._orderBy];
       builder._select = [...this._select];
       builder._withRelations = [...this._withRelations];
+      builder._trashed = this._trashed;
       builder._limit = size;
       builder._offset = page * size;
       const results = await builder.get();
@@ -24575,8 +25170,9 @@ class ModelQueryBuilder {
     const exec = getExecutor();
     const params = [];
     let sql2 = `SELECT ${column} FROM ${this._definition.table}`;
-    if (this._wheres.length > 0) {
-      sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
+    const whereBody = this.composeWhere(params);
+    if (whereBody) {
+      sql2 += ` WHERE ${whereBody}`;
     }
     if (this._orderBy.length > 0) {
       sql2 += ` ORDER BY ${this._orderBy.map((o2) => `${o2.column} ${o2.direction.toUpperCase()}`).join(", ")}`;
@@ -24593,8 +25189,9 @@ class ModelQueryBuilder {
     const exec = getExecutor();
     const params = [];
     let sql2 = `SELECT ${fn}(${column}) as v FROM ${this._definition.table}`;
-    if (this._wheres.length > 0) {
-      sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
+    const whereBody = this.composeWhere(params);
+    if (whereBody) {
+      sql2 += ` WHERE ${whereBody}`;
     }
     const row = await exec.get(sql2, params);
     return row?.v == null ? null : Number(row.v);
@@ -24625,10 +25222,10 @@ class ModelQueryBuilder {
     const entries = Object.entries(data);
     const sets = entries.map(([k2]) => `${k2} = ?`).join(", ");
     const params = entries.map(([, v2]) => v2);
-    if (this._definition.traits?.useTimestamps) {
+    if (timestampsEnabled(this._definition)) {
       params.push(formatNow());
     }
-    let sql2 = `UPDATE ${this._definition.table} SET ${sets}${this._definition.traits?.useTimestamps ? ", updated_at = ?" : ""}`;
+    let sql2 = `UPDATE ${this._definition.table} SET ${sets}${timestampsEnabled(this._definition) ? ", updated_at = ?" : ""}`;
     if (this._wheres.length > 0) {
       sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
     }
@@ -24674,10 +25271,13 @@ function createModel(definition) {
     limit: (count) => new ModelQueryBuilder(definition).limit(count),
     take: (count) => new ModelQueryBuilder(definition).take(count),
     skip: (count) => new ModelQueryBuilder(definition).skip(count),
+    withTrashed: () => new ModelQueryBuilder(definition).withTrashed(),
+    onlyTrashed: () => new ModelQueryBuilder(definition).onlyTrashed(),
     async find(id) {
       const exec = getExecutor();
       const pk = definition.primaryKey || "id";
-      const row = await exec.get(`SELECT * FROM ${definition.table} WHERE ${pk} = ?`, [id]);
+      const sd = softDeletesEnabled(definition) ? ` AND ${SOFT_DELETE_COLUMN} IS NULL` : "";
+      const row = await exec.get(`SELECT * FROM ${definition.table} WHERE ${pk} = ?${sd}`, [id]);
       return row ? new ModelInstance(definition, row) : undefined;
     },
     async findOrFail(id) {
@@ -24689,7 +25289,8 @@ function createModel(definition) {
     async findMany(ids) {
       const exec = getExecutor();
       const pk = definition.primaryKey || "id";
-      const rows = await exec.all(`SELECT * FROM ${definition.table} WHERE ${pk} IN (${ids.map(() => "?").join(", ")})`, ids);
+      const sd = softDeletesEnabled(definition) ? ` AND ${SOFT_DELETE_COLUMN} IS NULL` : "";
+      const rows = await exec.all(`SELECT * FROM ${definition.table} WHERE ${pk} IN (${ids.map(() => "?").join(", ")})${sd}`, ids);
       return rows.map((row) => new ModelInstance(definition, row));
     },
     all: () => new ModelQueryBuilder(definition).get(),
@@ -24804,10 +25405,10 @@ async function createTableFromModel(definition) {
     }
     columns.push(colDef);
   }
-  if (definition.traits?.useTimestamps) {
+  if (timestampsEnabled(definition)) {
     columns.push("created_at TEXT", "updated_at TEXT");
   }
-  if (definition.traits?.useSoftDeletes) {
+  if (softDeletesEnabled(definition)) {
     columns.push("deleted_at TEXT");
   }
   await exec.run(`CREATE TABLE IF NOT EXISTS ${definition.table} (${columns.join(", ")})`, []);
@@ -24852,7 +25453,7 @@ async function seedModel(definition, count, faker) {
       if (attr.factory)
         data[name] = attr.factory(faker);
     }
-    if (definition.traits?.useTimestamps) {
+    if (timestampsEnabled(definition)) {
       const now = formatNow();
       data.created_at = now;
       data.updated_at = now;
@@ -24863,7 +25464,7 @@ async function seedModel(definition, count, faker) {
     await exec.run(`INSERT INTO ${definition.table} (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`, Object.values(data));
   }
 }
-var SAFE_SQL_IDENTIFIER, _getModel = null, globalDb = null, _executor = null, _executorForDb = null, _executorDialect = null, _executorDatabase = null, snakeCaseCache, tableNameCache, relationCache;
+var SAFE_SQL_IDENTIFIER, _getModel = null, globalDb = null, _executor = null, _executorForDb = null, _executorDialect = null, _executorDatabase = null, SOFT_DELETE_COLUMN = "deleted_at", BTM_RELATED_ALIAS = "__btm_rel__", snakeCaseCache, tableNameCache, relationCache, RELATION_CACHE_MAX = 1000;
 var init_orm = __esm(() => {
   init_config();
   init_db();
@@ -26348,6 +26949,23 @@ async function loadModels(options) {
 }
 var init_loader = () => {};
 
+// src/relation-utils.ts
+function normalizeRelationEntry(entry) {
+  if (typeof entry === "string")
+    return { model: entry };
+  if (entry && typeof entry === "object" && typeof entry.model === "string") {
+    const e2 = entry;
+    return { model: e2.model, foreignKey: e2.foreignKey, onDelete: e2.onDelete };
+  }
+  return null;
+}
+function normalizeRelationList(rel) {
+  if (!rel)
+    return [];
+  const entries = Array.isArray(rel) ? rel : typeof rel === "object" ? Object.values(rel) : [];
+  return entries.map(normalizeRelationEntry).filter((x2) => x2 !== null);
+}
+
 // src/meta.ts
 function buildSchemaMeta(models) {
   const modelToTable = {};
@@ -26365,13 +26983,24 @@ function buildSchemaMeta(models) {
     const toRecord = (v2) => {
       if (!v2)
         return {};
+      const rec = {};
       if (Array.isArray(v2)) {
-        const rec = {};
-        for (const relName of v2)
-          rec[relName] = relName;
+        for (const item of v2) {
+          const n2 = normalizeRelationEntry(item);
+          if (n2)
+            rec[n2.model] = n2.model;
+        }
         return rec;
       }
-      return v2;
+      if (typeof v2 === "object") {
+        for (const [key, val] of Object.entries(v2)) {
+          const n2 = normalizeRelationEntry(val);
+          if (n2)
+            rec[key] = n2.model;
+        }
+        return rec;
+      }
+      return {};
     };
     const toBelongsToManyRecord = (v2) => {
       if (!v2)
@@ -26418,6 +27047,7 @@ function buildSchemaMeta(models) {
   }
   return { modelToTable, tableToModel, primaryKeys, relations, scopes: scopesByTable, models };
 }
+var init_meta = () => {};
 
 // src/migrations.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync9, writeFileSync as writeFileSync14 } from "fs";
@@ -26580,15 +27210,6 @@ function detectTypeFromValidationRule(rule) {
   }
   return;
 }
-function normalizeBelongsTo(belongsTo) {
-  if (!belongsTo)
-    return [];
-  if (Array.isArray(belongsTo))
-    return belongsTo;
-  if (typeof belongsTo === "object")
-    return Object.values(belongsTo);
-  return [];
-}
 function buildMigrationPlan2(models, options) {
   const meta = buildSchemaMeta(models);
   const tables = [];
@@ -26677,12 +27298,12 @@ function buildMigrationPlan2(models, options) {
       }
       columns.push(col);
     }
-    const belongsToModels = normalizeBelongsTo(model.belongsTo);
-    for (const relatedModel of belongsToModels) {
-      const fkColumnName = `${snakeCase(relatedModel)}_id`;
+    const belongsToRelations = normalizeRelationList(model.belongsTo);
+    for (const rel of belongsToRelations) {
+      const fkColumnName = rel.foreignKey ?? `${snakeCase(rel.model)}_id`;
       if (columns.some((c2) => c2.name === fkColumnName))
         continue;
-      const refTable = meta.modelToTable[relatedModel];
+      const refTable = meta.modelToTable[rel.model];
       if (!refTable)
         continue;
       const refPk = meta.primaryKeys[refTable] ?? "id";
@@ -26693,7 +27314,7 @@ function buildMigrationPlan2(models, options) {
         isUnique: false,
         isNullable: true,
         hasDefault: false,
-        references: { table: refTable, column: refPk }
+        references: { table: refTable, column: refPk, onDelete: rel.onDelete }
       });
     }
     const traits = model.traits;
@@ -27010,6 +27631,13 @@ function columnsAreDifferent(col1, col2) {
   }
   return false;
 }
+function referencesAreDifferent(r1, r2) {
+  if (Boolean(r1) !== Boolean(r2))
+    return true;
+  if (!r1 || !r2)
+    return false;
+  return r1.table !== r2.table || r1.column !== r2.column || r1.onDelete !== r2.onDelete || r1.onUpdate !== r2.onUpdate;
+}
 function mapIndexesByKey(indexes) {
   const map = {};
   for (const i2 of indexes) {
@@ -27153,6 +27781,13 @@ function generateDiffSql(previous, next) {
           info2(`-- Detected column type change: ${curr.table}.${colName} (${prevCol.type} -> ${currCol.type})`);
           hasChanges = true;
         }
+        if (referencesAreDifferent(prevCol.references, currCol.references) && currCol.references) {
+          const addFkStatement = driver.addForeignKey(curr.table, currCol.name, currCol.references.table, currCol.references.column, currCol.references.onDelete, currCol.references.onUpdate);
+          tableChanges.push(addFkStatement);
+          chunks.push(addFkStatement);
+          info2(`-- Detected foreign-key change: ${curr.table}.${colName} -> ${currCol.references.table}(${currCol.references.column})${currCol.references.onDelete ? ` ON DELETE ${currCol.references.onDelete}` : ""}`);
+          hasChanges = true;
+        }
       }
     }
     for (const colName of Object.keys(currCols)) {
@@ -27206,6 +27841,7 @@ var migrationCounter = 0, migrationsCreatedCount = 0, migrationsUpdatedCount = 0
 var init_migrations = __esm(() => {
   init_config();
   init_drivers();
+  init_meta();
 });
 
 // src/schema.ts
@@ -27240,6 +27876,7 @@ var init_src2 = __esm(() => {
   init_dynamodb_tooling_adapter();
   init_dynamodb();
   init_loader();
+  init_meta();
   init_migrations();
   init_orm();
 });
@@ -29283,7 +29920,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.25";
+var version2 = "0.1.27";
 
 // bin/cli.ts
 init_actions();
@@ -29309,6 +29946,15 @@ var cli = new CLI("query-builder");
 cli.command("introspect <dir>", "Load models and print inferred schema").option("--verbose", "Enable verbose logging").example("query-builder introspect ./app/Models --verbose").action(async (dir, _options) => {
   await introspect(dir, _options);
 });
+cli.command("introspect:db", "Reverse-introspect the live database into defineModel() source (#1047)").option("--table <table>", "Limit to a single table (repeatable)").example("query-builder introspect:db > app/Models/generated.ts").action(async (_options) => {
+  const t2 = _options?.table;
+  const tables = t2 ? Array.isArray(t2) ? t2 : [t2] : undefined;
+  const models = await introspectDatabase({ tables });
+  console.log(`import { defineModel } from 'bun-query-builder'
+
+${models.map((m2) => m2.source).join(`
+`)}`);
+});
 cli.command("sql <dir> <table>", "Build a sample query for a table").option("--limit <n>", "Limit rows", { default: 10 }).example("query-builder sql ./app/Models users --limit 5").action(async (dir, table, opts) => {
   await sql(dir, table, opts);
 });