bun-query-builder 0.1.24 → 0.1.26

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,14 +11754,14 @@ 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;
 });
 
 // src/db.ts
 var {SQL } = globalThis.Bun;
 import { Database } from "bun:sqlite";
-import process19 from "process";
 
 class SQLiteWrapper {
   db;
@@ -11993,6 +11993,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,43 +12015,42 @@ 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) {
-    if (config5.verbose) {
-      console.warn(`[query-builder] Failed to create connection: ${error.message}`);
-    }
-    try {
+    console.error(`[query-builder] Failed to create database connection for dialect '${dialect}': ${error.message}`);
+    if (dialect === "sqlite") {
       return createSQLiteSQL(":memory:");
-    } catch {
-      return {
-        query: () => Promise.resolve([]),
-        execute: () => Promise.resolve([]),
-        close: () => Promise.resolve()
-      };
     }
+    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 {
@@ -12051,7 +12065,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];
@@ -12066,20 +12080,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
@@ -12329,6 +12333,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}` : "";
@@ -12543,20 +12588,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) => {
@@ -12566,9 +12626,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 {
@@ -12648,6 +12714,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;
@@ -12732,6 +12828,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}`);
@@ -12871,6 +12979,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;
@@ -12965,6 +13113,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;
       },
@@ -12974,22 +13168,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;
@@ -13406,6 +13602,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;
@@ -13617,8 +13829,9 @@ function createQueryBuilder(state) {
       },
       whereBetween(column, start, end) {
         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;
       },
@@ -13630,9 +13843,30 @@ function createQueryBuilder(state) {
       },
       whereJsonContains(column, json) {
         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;
       },
@@ -13659,69 +13893,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) {
@@ -13762,7 +14012,8 @@ function createQueryBuilder(state) {
       },
       whereNotBetween(column, start, end) {
         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;
@@ -14030,7 +14281,7 @@ function createQueryBuilder(state) {
         return this;
       },
       join(table2, onLeft, operator, onRight) {
-        text = `${text} JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`;
+        insertJoin(`JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`);
         joinedTables.add(table2);
         return this;
       },
@@ -14039,44 +14290,37 @@ 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;
+        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;
+        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;
+        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;
+        insertJoin(`RIGHT JOIN ${table2} ON ${onLeft} ${operator} ${onRight}`);
         joinedTables.add(table2);
         return this;
       },
       crossJoin(table2) {
-        text = `${text} CROSS JOIN ${table2}`;
-        built = null;
+        insertJoin(`CROSS JOIN ${table2}`);
         joinedTables.add(table2);
         return this;
       },
       crossJoinSub(sub, alias) {
-        text += ` CROSS JOIN (${String(sub.toSQL())}) AS ${alias}`;
-        built = null;
+        insertJoin(`CROSS JOIN (${String(sub.toSQL())}) AS ${alias}`);
         joinedTables.add(alias);
         return this;
       },
@@ -14129,9 +14373,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)) {
@@ -14145,18 +14390,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;
       },
@@ -14167,13 +14413,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) {
@@ -14217,11 +14477,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;
@@ -14378,7 +14649,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) {
@@ -14433,7 +14704,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) {
@@ -14515,7 +14786,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) {
@@ -14533,7 +14804,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) {
@@ -14603,6 +14874,9 @@ function createQueryBuilder(state) {
       toParams() {
         return ensureBuilt().values?.() ?? [];
       },
+      __rawState() {
+        return { sql: reorderSelectClauses(text), params: [...whereParams] };
+      },
       raw() {
         return ensureBuilt().raw();
       },
@@ -14961,15 +15235,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(`;
@@ -15027,7 +15301,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) {
@@ -15501,55 +15775,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";
@@ -15652,7 +15943,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)
@@ -15959,7 +16251,7 @@ var init_cache = __esm(() => {
 });
 
 // src/actions/console.ts
-import process21 from "process";
+import process19 from "process";
 import { createInterface } from "readline";
 async function startConsole() {
   console.log("-- Query Builder Interactive Console");
@@ -15968,8 +16260,8 @@ async function startConsole() {
   console.log();
   const qb = createQueryBuilder();
   const rl = createInterface({
-    input: process21.stdin,
-    output: process21.stdout,
+    input: process19.stdin,
+    output: process19.stdout,
     prompt: "qb> "
   });
   let multilineBuffer = "";
@@ -16020,7 +16312,7 @@ Tips:
       if (cmd === ".exit" || cmd === ".quit") {
         console.log("Goodbye!");
         rl.close();
-        process21.exit(0);
+        process19.exit(0);
       } else if (cmd === ".help") {
         console.log(helpText);
       } else if (cmd === ".clear") {
@@ -16091,7 +16383,7 @@ Tips:
   rl.on("close", () => {
     console.log(`
 Goodbye!`);
-    process21.exit(0);
+    process19.exit(0);
   });
   rl.prompt();
 }
@@ -16469,9 +16761,9 @@ var init_db_info = __esm(() => {
 });
 
 // src/actions/db-optimize.ts
-import process22 from "process";
+import process21 from "process";
 async function dbOptimize(options = {}) {
-  const dialect = options.dialect || process22.env.DB_DIALECT || "postgres";
+  const dialect = options.dialect || process21.env.DB_DIALECT || "postgres";
   const aggressive = options.aggressive || false;
   if (options.verbose) {
     console.log(`Optimizing ${dialect} database${aggressive ? " (aggressive mode)" : ""}...`);
@@ -16511,7 +16803,7 @@ async function dbOptimize(options = {}) {
           await bunSql`ANALYZE TABLE ${bunSql(table)}`;
         }
       } else {
-        const dbName = process22.env.DB_NAME || "test";
+        const dbName = process21.env.DB_NAME || "test";
         const tables = await bunSql`
           SELECT table_name
           FROM information_schema.tables
@@ -16563,9 +16855,9 @@ var init_db_optimize = __esm(() => {
 });
 
 // src/actions/db-wipe.ts
-import process23 from "process";
+import process22 from "process";
 async function dbWipe(options = {}) {
-  const dialect = options.dialect || process23.env.DB_DIALECT || "postgres";
+  const dialect = options.dialect || process22.env.DB_DIALECT || "postgres";
   if (options.verbose) {
     console.log(`Wiping all tables from ${dialect} database...`);
   }
@@ -16579,7 +16871,7 @@ async function dbWipe(options = {}) {
       `;
       tables = result.map((row) => row.tablename);
     } else if (dialect === "mysql") {
-      const dbName = process23.env.DB_NAME || "test";
+      const dbName = process22.env.DB_NAME || "test";
       const result = await bunSql`
         SELECT table_name
         FROM information_schema.tables
@@ -16872,10 +17164,130 @@ 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";
-import process24 from "process";
+import process23 from "process";
 function findWorkspaceRoot(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname5(currentPath)) {
@@ -16884,10 +17296,10 @@ function findWorkspaceRoot(startPath) {
     }
     currentPath = dirname5(currentPath);
   }
-  return process24.cwd();
+  return process23.cwd();
 }
 async function makeModel(name, options = {}) {
-  const workspaceRoot = findWorkspaceRoot(process24.cwd());
+  const workspaceRoot = findWorkspaceRoot(process23.cwd());
   const modelsDir = options.dir || join7(workspaceRoot, "app/Models");
   if (!existsSync14(modelsDir)) {
     mkdirSync5(modelsDir, { recursive: true });
@@ -17444,7 +17856,7 @@ __export(exports_migrate, {
 import { existsSync as existsSync16, mkdirSync as mkdirSync7, mkdtempSync, readdirSync as readdirSync6, readFileSync as readFileSync3, rmSync, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir } from "os";
 import { join as join9 } from "path";
-import process25 from "process";
+import process24 from "process";
 function info(message) {
   if (config5.verbose)
     console.log(message);
@@ -17491,7 +17903,7 @@ function savePlanSnapshot(workspaceRoot, dialect, plan) {
   info(`-- Model snapshot saved to ${snapshotPath}`);
 }
 function getWorkspaceRoot() {
-  return process25.cwd();
+  return process24.cwd();
 }
 function ensureSqlDirectory(workspaceRoot) {
   const sqlDir = getSqlDirectory(workspaceRoot);
@@ -17503,7 +17915,7 @@ function ensureSqlDirectory(workspaceRoot) {
 }
 async function generateMigration(dir, opts = {}) {
   if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
+    dir = join9(process24.cwd(), "app/Models");
   }
   const dialect = opts.dialect || config5.dialect || "postgres";
   const workspaceRoot = getWorkspaceRoot();
@@ -17558,7 +17970,7 @@ async function generateMigration(dir, opts = {}) {
 }
 async function executeMigration(dir) {
   if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
+    dir = join9(process24.cwd(), "app/Models");
   }
   const workspaceRoot = getWorkspaceRoot();
   const sqlDir = ensureSqlDirectory(workspaceRoot);
@@ -17623,7 +18035,7 @@ async function executeMigration(dir) {
 }
 async function resetDatabase(dir, opts = {}) {
   if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
+    dir = join9(process24.cwd(), "app/Models");
   }
   const dialect = opts.dialect || "postgres";
   const driver = getDialectDriver(dialect);
@@ -17716,7 +18128,7 @@ async function resetDatabase(dir, opts = {}) {
 }
 async function deleteMigrationFiles(dir, workspaceRoot, opts = {}) {
   if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
+    dir = join9(process24.cwd(), "app/Models");
   }
   if (!workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
@@ -17814,9 +18226,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";
+import process25 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)) {
@@ -17825,16 +18279,17 @@ function findWorkspaceRoot2(startPath) {
     }
     currentPath = dirname7(currentPath);
   }
-  return process26.cwd();
+  return process25.cwd();
 }
 function getSqlDirectory2(workspaceRoot) {
   if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot2(process26.cwd());
+    workspaceRoot = findWorkspaceRoot2(process25.cwd());
   }
   return join10(workspaceRoot, "database", "migrations");
 }
 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();
@@ -17864,13 +18319,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}`);
@@ -17881,24 +18348,25 @@ 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();
 });
 
 // src/actions/migrate-status.ts
 import { existsSync as existsSync18, readdirSync as readdirSync8 } from "fs";
 import { dirname as dirname8, join as join11 } from "path";
-import process27 from "process";
+import process26 from "process";
 function findWorkspaceRoot3(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname8(currentPath)) {
@@ -17907,11 +18375,11 @@ function findWorkspaceRoot3(startPath) {
     }
     currentPath = dirname8(currentPath);
   }
-  return process27.cwd();
+  return process26.cwd();
 }
 function getSqlDirectory3(workspaceRoot) {
   if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot3(process27.cwd());
+    workspaceRoot = findWorkspaceRoot3(process26.cwd());
   }
   return join11(workspaceRoot, "database", "migrations");
 }
@@ -18005,9 +18473,9 @@ var init_migrate_status = __esm(() => {
 // src/actions/model-show.ts
 import { readdirSync as readdirSync9 } from "fs";
 import { extname as extname2, join as join12 } from "path";
-import process28 from "process";
+import process27 from "process";
 async function modelShow(modelName, options = {}) {
-  const dir = options.dir || join12(process28.cwd(), "app/Models");
+  const dir = options.dir || join12(process27.cwd(), "app/Models");
   try {
     const files = readdirSync9(dir);
     const modelFile = files.find((f) => {
@@ -18126,7 +18594,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 = [];
@@ -18152,7 +18620,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`);
@@ -18189,7 +18657,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
         });
@@ -18221,9 +18689,9 @@ var init_query_explain_all = __esm(() => {
 // src/actions/relation-diagram.ts
 import { writeFileSync as writeFileSync12 } from "fs";
 import { join as join14 } from "path";
-import process29 from "process";
+import process28 from "process";
 async function relationDiagram(options = {}) {
-  const dir = options.dir || join14(process29.cwd(), "app/Models");
+  const dir = options.dir || join14(process28.cwd(), "app/Models");
   const format = options.format || "mermaid";
   try {
     const models = await loadModels({ modelsDir: dir });
@@ -18345,7 +18813,7 @@ var init_relation_diagram = __esm(() => {
 // src/actions/seed.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync8, readdirSync as readdirSync11, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname9, join as join15 } from "path";
-import process30 from "process";
+import process29 from "process";
 function findWorkspaceRoot4(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname9(currentPath)) {
@@ -18354,7 +18822,7 @@ function findWorkspaceRoot4(startPath) {
     }
     currentPath = dirname9(currentPath);
   }
-  return process30.cwd();
+  return process29.cwd();
 }
 async function loadSeeders(seedersDir) {
   if (!existsSync19(seedersDir)) {
@@ -18386,7 +18854,7 @@ async function loadSeeders(seedersDir) {
   return seeders;
 }
 async function runSeeders(config6 = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot4(process29.cwd());
   const seedersDir = config6.seedersDir || join15(workspaceRoot, "database/seeders");
   const verbose = config6.verbose ?? true;
   if (verbose) {
@@ -18421,7 +18889,7 @@ async function runSeeders(config6 = {}) {
   }
 }
 async function runSeeder(className, options = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot4(process29.cwd());
   const seedersDir = join15(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
   if (verbose) {
@@ -18445,7 +18913,7 @@ async function runSeeder(className, options = {}) {
   }
 }
 async function makeSeeder(name) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot4(process29.cwd());
   const seedersDir = join15(workspaceRoot, "database/seeders");
   if (!existsSync19(seedersDir)) {
     mkdirSync8(seedersDir, { recursive: true });
@@ -18509,7 +18977,7 @@ export default class ${className} extends Seeder {
   console.log(`-- \u2713 Created seeder: ${filePath}`);
 }
 async function freshDatabase(options = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot4(process29.cwd());
   const modelsDir = options.modelsDir || join15(workspaceRoot, "app/Models");
   const seedersDir = options.seedersDir || join15(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
@@ -18571,7 +19039,7 @@ var init_unsafe = __esm(() => {
 // src/actions/validate.ts
 import { existsSync as existsSync20 } from "fs";
 import { dirname as dirname10, join as join16 } from "path";
-import process31 from "process";
+import process30 from "process";
 function findWorkspaceRoot5(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname10(currentPath)) {
@@ -18580,11 +19048,11 @@ function findWorkspaceRoot5(startPath) {
     }
     currentPath = dirname10(currentPath);
   }
-  return process31.cwd();
+  return process30.cwd();
 }
 async function validateSchema(dir) {
   if (!dir) {
-    dir = join16(findWorkspaceRoot5(process31.cwd()), "app/Models");
+    dir = join16(findWorkspaceRoot5(process30.cwd()), "app/Models");
   }
   const dialect = config5.dialect || "postgres";
   console.log("-- Validating Schema");
@@ -18803,6 +19271,7 @@ var init_actions = __esm(() => {
   init_file();
   init_inspect();
   init_introspect();
+  init_introspect_db();
   init_make_model();
   init_migrate();
   init_migrate_generate();
@@ -23273,6 +23742,10 @@ var init_src = __esm(() => {
 
 // src/orm.ts
 import { Database as Database2 } from "bun:sqlite";
+function formatNow() {
+  const iso = new Date().toISOString();
+  return config5.dialect === "mysql" ? iso.slice(0, 19).replace("T", " ") : iso;
+}
 function assertValidIdentifier(name, context) {
   if (typeof name !== "string" || name.length === 0)
     throw new TypeError(`[bun-query-builder] ${context}: identifier must be a non-empty string, got ${typeof name}`);
@@ -23293,19 +23766,138 @@ function getModelFromRegistry(name) {
   }
   return _getModel(name);
 }
+function toPostgresPlaceholders(sql2) {
+  let i2 = 0;
+  return sql2.replace(/\?/g, () => `$${++i2}`);
+}
+function extractChanges(res) {
+  if (res == null)
+    return 0;
+  if (typeof res.affectedRows === "number")
+    return res.affectedRows;
+  if (typeof res.count === "number")
+    return res.count;
+  if (Array.isArray(res))
+    return res.length;
+  return 0;
+}
+function extractInsertId(res) {
+  if (res == null || typeof res !== "object")
+    return null;
+  if ("insertId" in res && res.insertId != null)
+    return res.insertId;
+  if ("lastInsertRowid" in res && res.lastInsertRowid != null)
+    return res.lastInsertRowid;
+  return null;
+}
+
+class SqliteExecutor {
+  sqliteDb;
+  dialect = "sqlite";
+  constructor(sqliteDb) {
+    this.sqliteDb = sqliteDb;
+  }
+  all(sql2, params) {
+    return Promise.resolve(this.sqliteDb.query(sql2).all(...params));
+  }
+  get(sql2, params) {
+    return Promise.resolve(this.sqliteDb.query(sql2).get(...params) ?? undefined);
+  }
+  run(sql2, params) {
+    const r2 = this.sqliteDb.run(sql2, params);
+    return Promise.resolve({ changes: r2.changes, lastInsertId: r2.lastInsertRowid });
+  }
+  insert(sql2, params) {
+    return this.run(sql2, params);
+  }
+}
+
+class DriverExecutor {
+  dialect;
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  conn() {
+    return getOrCreateBunSql();
+  }
+  text(sql2) {
+    return this.dialect === "postgres" ? toPostgresPlaceholders(sql2) : sql2;
+  }
+  async all(sql2, params) {
+    const rows = await this.conn().unsafe(this.text(sql2), params);
+    return Array.isArray(rows) ? rows : [];
+  }
+  async get(sql2, params) {
+    const rows = await this.conn().unsafe(this.text(sql2), params);
+    if (Array.isArray(rows))
+      return rows[0] ?? undefined;
+    return rows ?? undefined;
+  }
+  async run(sql2, params) {
+    const res = await this.conn().unsafe(this.text(sql2), params);
+    return { changes: extractChanges(res), lastInsertId: extractInsertId(res) };
+  }
+  async insert(sql2, params, primaryKey) {
+    if (this.dialect === "postgres") {
+      const rows = await this.conn().unsafe(`${toPostgresPlaceholders(sql2)} RETURNING ${primaryKey}`, params);
+      const row = Array.isArray(rows) ? rows[0] : rows;
+      return { changes: 1, lastInsertId: row ? row[primaryKey] ?? null : null };
+    }
+    const res = await this.conn().unsafe(sql2, params);
+    let id = extractInsertId(res);
+    if (id == null) {
+      const rows = await this.conn().unsafe("SELECT LAST_INSERT_ID() as id", []);
+      const row = Array.isArray(rows) ? rows[0] : rows;
+      id = row?.id ?? null;
+    }
+    return { changes: extractChanges(res) || 1, lastInsertId: id };
+  }
+}
 function configureOrm(options) {
   if (options.database instanceof Database2) {
     globalDb = options.database;
   } else {
     globalDb = new Database2(options.database || ":memory:", { create: true });
   }
-  preparedStatementCache.clear();
+  _executor = null;
+  _executorForDb = null;
 }
-function getDatabase() {
-  if (!globalDb) {
-    globalDb = new Database2(":memory:", { create: true });
+function getExecutor() {
+  if (globalDb) {
+    if (!_executor || _executorForDb !== globalDb) {
+      _executor = new SqliteExecutor(globalDb);
+      _executorForDb = globalDb;
+      _executorDialect = "sqlite";
+      _executorDatabase = null;
+    }
+    return _executor;
   }
-  return globalDb;
+  const dialect = config5.dialect;
+  const database = config5.database?.database ?? null;
+  if (_executor && _executorForDb === null && _executorDialect === dialect && _executorDatabase === database)
+    return _executor;
+  _executorForDb = null;
+  _executorDialect = dialect;
+  _executorDatabase = database;
+  if (dialect === "sqlite")
+    _executor = new SqliteExecutor(new Database2(database || ":memory:", { create: true }));
+  else
+    _executor = new DriverExecutor(dialect);
+  return _executor;
+}
+function getDatabase() {
+  const exec = getExecutor();
+  if (exec.sqliteDb)
+    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;
@@ -23459,8 +24051,8 @@ class ModelInstance {
     Object.assign(this._attributes, data);
     return this;
   }
-  save() {
-    const db = getDatabase();
+  async save() {
+    const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
     const hooks = this._definition.hooks;
     const setters = this._definition.set || {};
@@ -23470,88 +24062,108 @@ class ModelInstance {
       }
     }
     if (this._attributes[pk]) {
-      hooks?.beforeUpdate?.(this, this.getChanges());
+      await hooks?.beforeUpdate?.(this, this.getChanges());
       const changes = this.getChanges();
       const changeKeys = Object.keys(changes);
       if (changeKeys.length > 0) {
         const sets = changeKeys.map((k2) => `${k2} = ?`).join(", ");
         const values = [...Object.values(changes), this._attributes[pk]];
-        if (this._definition.traits?.useTimestamps) {
-          const now = new Date().toISOString();
-          db.run(`UPDATE ${this._definition.table} SET ${sets}, updated_at = ? WHERE ${pk} = ?`, [...Object.values(changes), now, this._attributes[pk]]);
+        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 {
-          db.run(`UPDATE ${this._definition.table} SET ${sets} WHERE ${pk} = ?`, values);
+          await exec.run(`UPDATE ${this._definition.table} SET ${sets} WHERE ${pk} = ?`, values);
         }
       }
-      hooks?.afterUpdate?.(this);
+      await hooks?.afterUpdate?.(this);
     } else {
       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) {
-        const now = new Date().toISOString();
+      if (timestampsEnabled(this._definition)) {
+        const now = formatNow();
         data.created_at = now;
         data.updated_at = now;
       }
       if (this._definition.traits?.useUuid && !data.uuid) {
         data.uuid = crypto.randomUUID();
       }
-      hooks?.beforeCreate?.(data);
+      await hooks?.beforeCreate?.(data);
       const columns = Object.keys(data);
       const placeholders = columns.map(() => "?").join(", ");
-      const result = db.run(`INSERT INTO ${this._definition.table} (${columns.join(", ")}) VALUES (${placeholders})`, Object.values(data));
+      const result = await exec.insert(`INSERT INTO ${this._definition.table} (${columns.join(", ")}) VALUES (${placeholders})`, Object.values(data), pk);
       for (const [key, value] of Object.entries(data)) {
         this._attributes[key] = value;
       }
-      this._attributes[pk] = result.lastInsertRowid;
-      hooks?.afterCreate?.(this);
+      if (result.lastInsertId != null)
+        this._attributes[pk] = result.lastInsertId;
+      await hooks?.afterCreate?.(this);
     }
     this._original = { ...this._attributes };
     this._hasSaved = true;
     return this;
   }
-  update(data) {
+  async update(data) {
     this.fill(data);
     return this.save();
   }
-  fresh() {
-    const db = getDatabase();
+  async fresh() {
+    const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
     const id = this._attributes[pk];
     if (id == null)
       return null;
-    const row = db.query(`SELECT * FROM ${this._definition.table} WHERE ${pk} = ?`).get(id);
+    const row = await exec.get(`SELECT * FROM ${this._definition.table} WHERE ${pk} = ?`, [id]);
     if (!row)
       return null;
     return new ModelInstance(this._definition, row);
   }
-  delete() {
-    const db = getDatabase();
+  async delete() {
+    const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
     const pkValue = this._attributes[pk];
     const hooks = this._definition.hooks;
     if (!pkValue)
       throw new Error("Cannot delete a model without a primary key");
-    hooks?.beforeDelete?.(this);
-    if (this._definition.traits?.useSoftDeletes) {
-      db.run(`UPDATE ${this._definition.table} SET deleted_at = ? WHERE ${pk} = ?`, [new Date().toISOString(), pkValue]);
+    await hooks?.beforeDelete?.(this);
+    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 {
-      db.run(`DELETE FROM ${this._definition.table} WHERE ${pk} = ?`, [pkValue]);
+      await exec.run(`DELETE FROM ${this._definition.table} WHERE ${pk} = ?`, [pkValue]);
     }
-    hooks?.afterDelete?.(this);
+    await hooks?.afterDelete?.(this);
     return true;
   }
-  refresh() {
-    const db = getDatabase();
+  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";
     const pkValue = this._attributes[pk];
     if (!pkValue)
       throw new Error("Cannot refresh a model without a primary key");
-    const row = db.query(`SELECT * FROM ${this._definition.table} WHERE ${pk} = ?`).get(pkValue);
+    const row = await exec.get(`SELECT * FROM ${this._definition.table} WHERE ${pk} = ?`, [pkValue]);
     if (!row)
       return null;
     this._attributes = row;
@@ -23849,9 +24461,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);
@@ -23872,58 +24498,51 @@ 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;
     });
   }
-  get() {
-    const db = getDatabase();
+  async get() {
+    const exec = getExecutor();
     const { sql: sql2, params } = this.buildSelect();
-    const rows = db.query(sql2).all(...params);
+    const rows = await exec.all(sql2, params);
     return this.hydrateRows(rows);
   }
-  first() {
+  async first() {
     this._limit = 1;
-    return this.get()[0];
+    return (await this.get())[0];
   }
-  count() {
-    const db = getDatabase();
+  async count() {
+    const exec = getExecutor();
     let sql2 = `SELECT COUNT(*) as count FROM ${this.pivotTable} WHERE ${this.fkParent} = ?`;
     const params = [this.parentId];
     for (const w of this._pivotWheres) {
       sql2 += ` AND ${w.sql}`;
       params.push(...w.params);
     }
-    return db.query(sql2).get(...params).count;
+    const row = await exec.get(sql2, params);
+    return Number(row?.count ?? 0);
   }
-  exists() {
-    return this.count() > 0;
+  async exists() {
+    return await this.count() > 0;
   }
   now() {
-    return new Date().toISOString();
+    return formatNow();
   }
-  attach(idOrIds, extras = {}) {
-    const db = getDatabase();
+  async attach(idOrIds, extras = {}) {
+    const exec = getExecutor();
     const ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
     if (ids.length === 0)
       return 0;
@@ -23945,13 +24564,13 @@ class BelongsToManyRelationBuilder {
       const placeholders = cols.map(() => "?").join(", ");
       const sql2 = `INSERT INTO ${this.pivotTable} (${cols.join(", ")}) VALUES (${placeholders})`;
       const params = cols.map((c2) => row[c2]);
-      db.run(sql2, params);
+      await exec.run(sql2, params);
       inserted++;
     }
     return inserted;
   }
-  detach(idOrIds) {
-    const db = getDatabase();
+  async detach(idOrIds) {
+    const exec = getExecutor();
     let sql2 = `DELETE FROM ${this.pivotTable} WHERE ${this.fkParent} = ?`;
     const params = [this.parentId];
     if (idOrIds !== undefined && idOrIds !== null) {
@@ -23962,10 +24581,10 @@ class BelongsToManyRelationBuilder {
       sql2 += ` AND ${this.fkRelated} IN (${placeholders})`;
       params.push(...ids);
     }
-    return db.run(sql2, params).changes;
+    return (await exec.run(sql2, params)).changes;
   }
-  updateExistingPivot(relatedId, extras) {
-    const db = getDatabase();
+  async updateExistingPivot(relatedId, extras) {
+    const exec = getExecutor();
     const updates = { ...extras };
     if (this._resolved.pivotTimestamps && updates.updated_at === undefined) {
       updates.updated_at = this.now();
@@ -23976,10 +24595,10 @@ class BelongsToManyRelationBuilder {
     const setClause = cols.map((c2) => `${c2} = ?`).join(", ");
     const sql2 = `UPDATE ${this.pivotTable} SET ${setClause} WHERE ${this.fkParent} = ? AND ${this.fkRelated} = ?`;
     const params = [...cols.map((c2) => updates[c2]), this.parentId, relatedId];
-    return db.run(sql2, params).changes;
+    return (await exec.run(sql2, params)).changes;
   }
-  sync(items) {
-    const db = getDatabase();
+  async sync(items) {
+    const exec = getExecutor();
     const desired = new Map;
     for (const item of items) {
       if (item != null && typeof item === "object" && "id" in item) {
@@ -23989,41 +24608,41 @@ class BelongsToManyRelationBuilder {
         desired.set(item, {});
       }
     }
-    const current = db.query(`SELECT * FROM ${this.pivotTable} WHERE ${this.fkParent} = ?`).all(this.parentId);
+    const current = await exec.all(`SELECT * FROM ${this.pivotTable} WHERE ${this.fkParent} = ?`, [this.parentId]);
     const currentIds = new Set(current.map((r2) => r2[this.fkRelated]));
     const attached = [];
     const detached = [];
     const updated = [];
     const toDetach = [...currentIds].filter((id) => !desired.has(id));
     if (toDetach.length > 0) {
-      this.detach(toDetach);
+      await this.detach(toDetach);
       detached.push(...toDetach);
     }
     for (const [id, extras] of desired) {
       if (!currentIds.has(id)) {
-        this.attach(id, extras);
+        await this.attach(id, extras);
         attached.push(id);
       } else if (Object.keys(extras).length > 0) {
-        this.updateExistingPivot(id, extras);
+        await this.updateExistingPivot(id, extras);
         updated.push(id);
       }
     }
     return { attached, detached, updated };
   }
-  toggle(idOrIds) {
-    const db = getDatabase();
+  async toggle(idOrIds) {
+    const exec = getExecutor();
     const ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
     if (ids.length === 0)
       return { attached: [], detached: [] };
     const placeholders = ids.map(() => "?").join(", ");
-    const present = db.query(`SELECT ${this.fkRelated} FROM ${this.pivotTable} WHERE ${this.fkParent} = ? AND ${this.fkRelated} IN (${placeholders})`).all(this.parentId, ...ids);
+    const present = await exec.all(`SELECT ${this.fkRelated} FROM ${this.pivotTable} WHERE ${this.fkParent} = ? AND ${this.fkRelated} IN (${placeholders})`, [this.parentId, ...ids]);
     const presentIds = new Set(present.map((r2) => r2[this.fkRelated]));
     const toAttach = ids.filter((id) => !presentIds.has(id));
     const toDetach = ids.filter((id) => presentIds.has(id));
     if (toAttach.length > 0)
-      this.attach(toAttach);
+      await this.attach(toAttach);
     if (toDetach.length > 0)
-      this.detach(toDetach);
+      await this.detach(toDetach);
     return { attached: toAttach, detached: toDetach };
   }
 }
@@ -24036,9 +24655,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" });
@@ -24216,11 +24844,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(", ")}`;
@@ -24234,10 +24875,10 @@ class ModelQueryBuilder {
   toSql() {
     return this.buildQuery();
   }
-  eagerLoadRelations(instances) {
+  async eagerLoadRelations(instances) {
     if (instances.length === 0 || this._withRelations.length === 0)
       return;
-    const db = getDatabase();
+    const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
     for (const relationName of this._withRelations) {
       const cacheKey = `${this._definition.name}:${relationName}`;
@@ -24253,7 +24894,7 @@ class ModelQueryBuilder {
         if (parentIds.length === 0)
           continue;
         const placeholders = parentIds.map(() => "?").join(", ");
-        const rows = db.query(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.foreignKey} IN (${placeholders})`).all(...parentIds);
+        const rows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.foreignKey} IN (${placeholders})`, parentIds);
         const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
         const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
         if (rel.type === "hasMany") {
@@ -24285,7 +24926,7 @@ class ModelQueryBuilder {
         if (uniqueFkValues.length === 0)
           continue;
         const placeholders = uniqueFkValues.map(() => "?").join(", ");
-        const rows = db.query(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.localKey} IN (${placeholders})`).all(...uniqueFkValues);
+        const rows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.localKey} IN (${placeholders})`, uniqueFkValues);
         const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
         const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
         const byPk = new Map;
@@ -24305,7 +24946,7 @@ class ModelQueryBuilder {
         if (!rel.pivotTable || !rel.pivotFkParent || !rel.pivotFkRelated)
           continue;
         const pivotPlaceholders = parentIds.map(() => "?").join(", ");
-        const pivotRows = db.query(`SELECT * FROM ${rel.pivotTable} WHERE ${rel.pivotFkParent} IN (${pivotPlaceholders})`).all(...parentIds);
+        const pivotRows = await exec.all(`SELECT * FROM ${rel.pivotTable} WHERE ${rel.pivotFkParent} IN (${pivotPlaceholders})`, parentIds);
         if (pivotRows.length === 0) {
           for (const instance of instances)
             instance.setRelation(relationName, []);
@@ -24318,7 +24959,7 @@ class ModelQueryBuilder {
         let relatedRows = [];
         if (relatedIds.length > 0) {
           const relPlaceholders = relatedIds.map(() => "?").join(", ");
-          relatedRows = db.query(`SELECT * FROM ${rel.relatedTable} WHERE ${relatedPk} IN (${relPlaceholders})`).all(...relatedIds);
+          relatedRows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${relatedPk} IN (${relPlaceholders})`, relatedIds);
         }
         const relatedByPk = new Map;
         for (const r2 of relatedRows)
@@ -24352,75 +24993,77 @@ class ModelQueryBuilder {
       }
     }
   }
-  get() {
-    const db = getDatabase();
+  async get() {
+    const exec = getExecutor();
     const { sql: sql2, params } = this.buildQuery();
-    const rows = db.query(sql2).all(...params);
+    const rows = await exec.all(sql2, params);
     const instances = rows.map((row) => new ModelInstance(this._definition, row));
     if (this._withRelations.length > 0) {
-      this.eagerLoadRelations(instances);
+      await this.eagerLoadRelations(instances);
     }
     return instances;
   }
-  first() {
+  async first() {
     this._limit = 1;
-    return this.get()[0];
+    return (await this.get())[0];
   }
-  firstOrFail() {
-    const result = this.first();
+  async firstOrFail() {
+    const result = await this.first();
     if (!result)
       throw new Error(`No ${this._definition.name} found`);
     return result;
   }
-  last() {
+  async last() {
     const pk = this._definition.primaryKey || "id";
     this._orderBy = [{ column: pk, direction: "desc" }];
     this._limit = 1;
-    return this.get()[0];
+    return (await this.get())[0];
   }
-  count() {
-    const db = getDatabase();
+  async count() {
+    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}`;
     }
-    return db.query(sql2).get(...params).count;
+    const row = await exec.get(sql2, params);
+    return Number(row?.count ?? 0);
   }
-  exists() {
-    return this.count() > 0;
+  async exists() {
+    return await this.count() > 0;
   }
-  doesntExist() {
-    return this.count() === 0;
+  async doesntExist() {
+    return await this.count() === 0;
   }
-  sole() {
+  async sole() {
     this._limit = 2;
-    const results = this.get();
+    const results = await this.get();
     if (results.length === 0)
       throw new Error(`No ${this._definition.name} found`);
     if (results.length > 1)
       throw new Error(`Expected one ${this._definition.name}, found multiple`);
     return results[0];
   }
-  increment(column, amount = 1) {
+  async increment(column, amount = 1) {
     assertValidIdentifier(column, "increment(column)");
-    const db = getDatabase();
+    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(new Date().toISOString());
+      params.push(formatNow());
     }
     if (this._wheres.length > 0) {
       const clauses = this.buildWhereClauses(params);
       sql2 += ` WHERE ${clauses}`;
     }
-    return db.run(sql2, params).changes;
+    return (await exec.run(sql2, params)).changes;
   }
   decrement(column, amount = 1) {
     return this.increment(column, -amount);
   }
-  chunk(size, callback) {
+  async chunk(size, callback) {
     let page = 0;
     while (true) {
       const builder = new ModelQueryBuilder(this._definition);
@@ -24428,12 +25071,13 @@ 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 = builder.get();
+      const results = await builder.get();
       if (results.length === 0)
         break;
-      const result = callback(results);
+      const result = await callback(results);
       if (result === false)
         break;
       if (results.length < size)
@@ -24441,12 +25085,12 @@ class ModelQueryBuilder {
       page++;
     }
   }
-  paginate(page = 1, perPage = 15) {
-    const total = this.count();
+  async paginate(page = 1, perPage = 15) {
+    const total = await this.count();
     const lastPage = Math.ceil(total / perPage);
     this._limit = perPage;
     this._offset = (page - 1) * perPage;
-    const data = this.get();
+    const data = await this.get();
     return {
       data,
       total,
@@ -24459,13 +25103,14 @@ class ModelQueryBuilder {
       to: data.length > 0 ? (page - 1) * perPage + data.length : null
     };
   }
-  pluck(column) {
+  async pluck(column) {
     assertValidIdentifier(column, "pluck(column)");
-    const db = getDatabase();
+    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(", ")}`;
@@ -24474,19 +25119,20 @@ class ModelQueryBuilder {
       sql2 += ` LIMIT ${this._limit}`;
     if (this._offset !== undefined)
       sql2 += ` OFFSET ${this._offset}`;
-    const rows = db.query(sql2).all(...params);
+    const rows = await exec.all(sql2, params);
     return rows.map((r2) => r2[column]);
   }
-  aggregate(fn, column) {
+  async aggregate(fn, column) {
     assertValidIdentifier(column, `${fn}(column)`);
-    const db = getDatabase();
+    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 = db.query(sql2).get(...params);
-    return row?.v ?? null;
+    const row = await exec.get(sql2, params);
+    return row?.v == null ? null : Number(row.v);
   }
   max(column) {
     return this.aggregate("MAX", column);
@@ -24494,34 +25140,34 @@ class ModelQueryBuilder {
   min(column) {
     return this.aggregate("MIN", column);
   }
-  avg(column) {
-    return this.aggregate("AVG", column) || 0;
+  async avg(column) {
+    return await this.aggregate("AVG", column) || 0;
   }
-  sum(column) {
-    return this.aggregate("SUM", column) || 0;
+  async sum(column) {
+    return await this.aggregate("SUM", column) || 0;
   }
-  delete() {
-    const db = getDatabase();
+  async delete() {
+    const exec = getExecutor();
     const params = [];
     let sql2 = `DELETE FROM ${this._definition.table}`;
     if (this._wheres.length > 0) {
       sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
     }
-    return db.run(sql2, params).changes;
+    return (await exec.run(sql2, params)).changes;
   }
-  update(data) {
-    const db = getDatabase();
+  async update(data) {
+    const exec = getExecutor();
     const entries = Object.entries(data);
     const sets = entries.map(([k2]) => `${k2} = ?`).join(", ");
     const params = entries.map(([, v2]) => v2);
-    if (this._definition.traits?.useTimestamps) {
-      params.push(new Date().toISOString());
+    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)}`;
     }
-    return db.run(sql2, params).changes;
+    return (await exec.run(sql2, params)).changes;
   }
 }
 function createModel(definition) {
@@ -24563,28 +25209,26 @@ function createModel(definition) {
     limit: (count) => new ModelQueryBuilder(definition).limit(count),
     take: (count) => new ModelQueryBuilder(definition).take(count),
     skip: (count) => new ModelQueryBuilder(definition).skip(count),
-    find(id) {
-      const db = getDatabase();
+    withTrashed: () => new ModelQueryBuilder(definition).withTrashed(),
+    onlyTrashed: () => new ModelQueryBuilder(definition).onlyTrashed(),
+    async find(id) {
+      const exec = getExecutor();
       const pk = definition.primaryKey || "id";
-      const sql2 = `SELECT * FROM ${definition.table} WHERE ${pk} = ?`;
-      let stmt = preparedStatementCache.get(sql2);
-      if (!stmt) {
-        stmt = db.prepare(sql2);
-        preparedStatementCache.set(sql2, stmt);
-      }
-      const row = stmt.get(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;
     },
-    findOrFail(id) {
-      const result = model.find(id);
+    async findOrFail(id) {
+      const result = await model.find(id);
       if (!result)
         throw new Error(`${definition.name} with id ${id} not found`);
       return result;
     },
-    findMany(ids) {
-      const db = getDatabase();
+    async findMany(ids) {
+      const exec = getExecutor();
       const pk = definition.primaryKey || "id";
-      const rows = db.query(`SELECT * FROM ${definition.table} WHERE ${pk} IN (${ids.map(() => "?").join(", ")})`).all(...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(),
@@ -24601,44 +25245,47 @@ function createModel(definition) {
     whereNotBetween(column, range) {
       return new ModelQueryBuilder(definition).whereNotBetween(column, range);
     },
-    create(data) {
+    async create(data) {
       const instance = new ModelInstance(definition, data);
-      instance.save();
+      await instance.save();
       return instance;
     },
-    createMany(items) {
-      return items.map((data) => this.create(data));
+    async createMany(items) {
+      const out = [];
+      for (const data of items)
+        out.push(await this.create(data));
+      return out;
     },
-    updateOrCreate(search, data) {
+    async updateOrCreate(search, data) {
       let query = new ModelQueryBuilder(definition);
       for (const [key, value] of Object.entries(search)) {
         query = query.where(key, value);
       }
-      const existing = query.first();
+      const existing = await query.first();
       if (existing) {
-        existing.update(data);
+        await existing.update(data);
         return existing;
       }
       return this.create({ ...search, ...data });
     },
-    firstOrCreate(search, data) {
+    async firstOrCreate(search, data) {
       let query = new ModelQueryBuilder(definition);
       for (const [key, value] of Object.entries(search)) {
         query = query.where(key, value);
       }
-      const existing = query.first();
+      const existing = await query.first();
       return existing || this.create({ ...search, ...data });
     },
-    destroy(id) {
-      const db = getDatabase();
+    async destroy(id) {
+      const exec = getExecutor();
       const pk = definition.primaryKey || "id";
-      return db.run(`DELETE FROM ${definition.table} WHERE ${pk} = ?`, [id]).changes > 0;
+      return (await exec.run(`DELETE FROM ${definition.table} WHERE ${pk} = ?`, [id])).changes > 0;
     },
     remove(id) {
       return this.destroy(id);
     },
-    truncate() {
-      getDatabase().run(`DELETE FROM ${definition.table}`);
+    async truncate() {
+      await getExecutor().run(`DELETE FROM ${definition.table}`, []);
     },
     getDefinition: () => definition,
     getTable: () => definition.table,
@@ -24668,8 +25315,8 @@ function createModel(definition) {
     }
   });
 }
-function createTableFromModel(definition) {
-  const db = getDatabase();
+async function createTableFromModel(definition) {
+  const exec = getExecutor();
   const pk = definition.primaryKey || "id";
   const columns = [];
   columns.push(definition.autoIncrement !== false ? `${pk} INTEGER PRIMARY KEY AUTOINCREMENT` : `${pk} INTEGER PRIMARY KEY`);
@@ -24696,13 +25343,13 @@ 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");
   }
-  db.run(`CREATE TABLE IF NOT EXISTS ${definition.table} (${columns.join(", ")})`);
+  await exec.run(`CREATE TABLE IF NOT EXISTS ${definition.table} (${columns.join(", ")})`, []);
 }
 function createFakerCompatLayer(underlying) {
   return new Proxy(underlying, {
@@ -24726,7 +25373,7 @@ function createFakerCompatLayer(underlying) {
   });
 }
 async function seedModel(definition, count, faker) {
-  const db = getDatabase();
+  const exec = getExecutor();
   const seeder = definition.traits?.useSeeder;
   const seedCount = count ?? (typeof seeder === "object" && seeder ? seeder.count : 10);
   if (!faker) {
@@ -24744,24 +25391,25 @@ async function seedModel(definition, count, faker) {
       if (attr.factory)
         data[name] = attr.factory(faker);
     }
-    if (definition.traits?.useTimestamps) {
-      const now = new Date().toISOString();
+    if (timestampsEnabled(definition)) {
+      const now = formatNow();
       data.created_at = now;
       data.updated_at = now;
     }
     if (definition.traits?.useUuid)
       data.uuid = crypto.randomUUID();
     const columns = Object.keys(data);
-    db.run(`INSERT INTO ${definition.table} (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`, Object.values(data));
+    await exec.run(`INSERT INTO ${definition.table} (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`, Object.values(data));
   }
 }
-var SAFE_SQL_IDENTIFIER, _getModel = null, globalDb = null, snakeCaseCache, tableNameCache, relationCache, preparedStatementCache;
+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;
 var init_orm = __esm(() => {
+  init_config();
+  init_db();
   SAFE_SQL_IDENTIFIER = /^[A-Z_][A-Z0-9_]*$/i;
   snakeCaseCache = new Map;
   tableNameCache = new Map;
   relationCache = new Map;
-  preparedStatementCache = new Map;
 });
 
 // src/model.ts
@@ -26210,9 +26858,9 @@ function buildDatabaseSchema(models) {
 // src/loader.ts
 import { readdirSync as readdirSync12, statSync as statSync5 } from "fs";
 import { basename, extname as extname4 } from "path";
-import process33 from "process";
+import process31 from "process";
 async function loadModels(options) {
-  const cwd = options.cwd ?? process33.cwd();
+  const cwd = options.cwd ?? process31.cwd();
   const dir = options.modelsDir.startsWith("/") ? options.modelsDir : `${cwd}/${options.modelsDir}`;
   const result = {};
   const entries = readdirSync12(dir);
@@ -26239,6 +26887,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 = {};
@@ -26256,13 +26921,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)
@@ -26309,11 +26985,12 @@ 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";
 import { dirname as dirname11, join as join17 } from "path";
-import process35 from "process";
+import process33 from "process";
 function info2(message) {
   if (config5.verbose)
     console.log(message);
@@ -26329,10 +27006,10 @@ function findWorkspaceRoot6(startPath) {
     }
     currentPath = dirname11(currentPath);
   }
-  return process35.cwd();
+  return process33.cwd();
 }
 function ensureSqlDirectory2() {
-  const workspaceRoot = findWorkspaceRoot6(process35.cwd());
+  const workspaceRoot = findWorkspaceRoot6(process33.cwd());
   const sqlDir = join17(workspaceRoot, "database", "migrations");
   if (!existsSync21(sqlDir)) {
     mkdirSync9(sqlDir, { recursive: true });
@@ -26471,15 +27148,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 = [];
@@ -26568,12 +27236,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";
@@ -26584,7 +27252,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;
@@ -26901,6 +27569,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) {
@@ -27044,6 +27719,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)) {
@@ -27097,6 +27779,7 @@ var migrationCounter = 0, migrationsCreatedCount = 0, migrationsUpdatedCount = 0
 var init_migrations = __esm(() => {
   init_config();
   init_drivers();
+  init_meta();
 });
 
 // src/schema.ts
@@ -27131,6 +27814,7 @@ var init_src2 = __esm(() => {
   init_dynamodb_tooling_adapter();
   init_dynamodb();
   init_loader();
+  init_meta();
   init_migrations();
   init_orm();
 });
@@ -27140,7 +27824,7 @@ import { existsSync as existsSync23 } from "fs";
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
-import process36 from "process";
+import process35 from "process";
 import { EventEmitter } from "events";
 import process52 from "process";
 import process210 from "process";
@@ -27164,10 +27848,10 @@ class Telemetry {
     this.configPath = path.join(configDir, "telemetry.json");
   }
   async isEnabled() {
-    if (process36.env.DO_NOT_TRACK === "1" || process36.env.DO_NOT_TRACK === "true") {
+    if (process35.env.DO_NOT_TRACK === "1" || process35.env.DO_NOT_TRACK === "true") {
       return false;
     }
-    if (process36.env.NO_TELEMETRY === "1" || process36.env.NO_TELEMETRY === "true") {
+    if (process35.env.NO_TELEMETRY === "1" || process35.env.NO_TELEMETRY === "true") {
       return false;
     }
     const config6 = await this.loadConfig();
@@ -27196,7 +27880,7 @@ class Telemetry {
       ...data,
       timestamp: Date.now(),
       platform: os.platform(),
-      nodeVersion: process36.version
+      nodeVersion: process35.version
     };
     this.events.push(telemetryEvent);
     if (this.events.length >= 10) {
@@ -27252,7 +27936,7 @@ class Telemetry {
     const config6 = await this.loadConfig();
     return {
       enabled: config6.enabled,
-      doNotTrack: process36.env.DO_NOT_TRACK === "1" || process36.env.DO_NOT_TRACK === "true",
+      doNotTrack: process35.env.DO_NOT_TRACK === "1" || process35.env.DO_NOT_TRACK === "true",
       eventsQueued: this.events.length,
       lastSent: config6.lastSent
     };
@@ -29174,7 +29858,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.24";
+var version2 = "0.1.26";
 
 // bin/cli.ts
 init_actions();
@@ -29200,6 +29884,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);
 });