bun-query-builder 0.1.36 → 0.1.38

package/dist/src/index.js

@@ -17449,12 +17449,12 @@ async function readColumns(qb, dialect, table) {
   }
   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
+        (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]);
+      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 || ""),
@@ -17463,9 +17463,9 @@ async function readColumns(qb, dialect, table) {
     }));
   }
   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]);
+    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 ?? ""),
@@ -17512,6 +17512,281 @@ async function introspectDatabase(opts = {}) {
   }
   return out;
 }
+function sqlTypeToNormalized(rawType, dialect, ctx) {
+  if (ctx?.enumValues && ctx.enumValues.length > 0)
+    return "enum";
+  const t = String(rawType || "").toLowerCase().trim();
+  const base = t.replace(/\(.*$/, "").replace(/\s+/g, " ").trim();
+  if (dialect === "mysql" && /^tinyint\(1\)/.test(t))
+    return "boolean";
+  if (/^bool/.test(base))
+    return "boolean";
+  if (base === "int8" || base === "bigint" || base === "bigserial")
+    return "bigint";
+  if (/^(?:int|integer|smallint|mediumint|serial|int2|int4|tinyint)/.test(base))
+    return "integer";
+  if (/^(?:varchar|character varying|nvarchar|nchar|char|character|bpchar)/.test(base)) {
+    const m = t.match(/\((\d+)\)/);
+    const len = m ? Number(m[1]) : undefined;
+    return len !== undefined && len > 255 ? "text" : "string";
+  }
+  if (/text|clob/.test(base))
+    return "text";
+  if (base === "float8" || /^double/.test(base))
+    return "double";
+  if (/^(?:real|float4|float)/.test(base))
+    return "float";
+  if (/^(?:numeric|decimal|money)/.test(base))
+    return "decimal";
+  if (base === "date")
+    return "date";
+  if (/^(?:timestamp|datetime)/.test(base))
+    return "datetime";
+  if (/^time/.test(base))
+    return "string";
+  if (/json/.test(base))
+    return "json";
+  if (/^enum/.test(base))
+    return "enum";
+  return "string";
+}
+function stripIndexPrefix(physicalName, table) {
+  const prefix = `${table}_`;
+  return physicalName.startsWith(prefix) ? physicalName.slice(prefix.length) : physicalName;
+}
+function asAction(raw2) {
+  const v = String(raw2 ?? "").toLowerCase().trim();
+  if (v === "cascade" || v === "restrict" || v === "set null")
+    return v;
+  return;
+}
+async function buildSqliteTable(qb, table) {
+  const colRows = await qb.unsafe(`PRAGMA table_info(${JSON.stringify(table)})`);
+  const idxList = await qb.unsafe(`PRAGMA index_list(${JSON.stringify(table)})`);
+  const fkList = await qb.unsafe(`PRAGMA foreign_key_list(${JSON.stringify(table)})`);
+  const ddlRows = await qb.unsafe(`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?`, [table]);
+  const ddl = String(ddlRows?.[0]?.sql ?? "");
+  const fkByColumn = new Map;
+  for (const fk of fkList) {
+    fkByColumn.set(String(fk.from), {
+      table: String(fk.table),
+      column: String(fk.to ?? "id"),
+      onDelete: asAction(fk.on_delete),
+      onUpdate: asAction(fk.on_update)
+    });
+  }
+  const indexes = [];
+  const uniqueColumns = new Set;
+  for (const idx of idxList) {
+    const origin = String(idx.origin ?? "");
+    const physName = String(idx.name ?? "");
+    if (origin === "pk" || physName.startsWith("sqlite_autoindex_"))
+      continue;
+    const info = await qb.unsafe(`PRAGMA index_info(${JSON.stringify(physName)})`);
+    const columns2 = info.map((r) => String(r.name)).filter(Boolean);
+    if (columns2.length === 0)
+      continue;
+    const isUnique = Number(idx.unique) === 1;
+    if (isUnique && columns2.length === 1)
+      uniqueColumns.add(columns2[0]);
+    indexes.push({ name: stripIndexPrefix(physName, table), columns: columns2, type: isUnique ? "unique" : "index" });
+  }
+  const columns = colRows.map((r) => {
+    const name = String(r.name);
+    const enumValues = parseSqliteCheckEnum(ddl, name);
+    const isPrimaryKey = Number(r.pk) > 0;
+    const dflt = r.dflt_value;
+    const hasDefault = dflt !== null && dflt !== undefined;
+    return {
+      name,
+      type: sqlTypeToNormalized(String(r.type ?? ""), "sqlite", { enumValues }),
+      isPrimaryKey,
+      isUnique: uniqueColumns.has(name),
+      isNullable: isPrimaryKey ? false : Number(r.notnull) === 0,
+      hasDefault,
+      defaultValue: hasDefault ? normalizeRawDefault(dflt) : undefined,
+      enumValues,
+      references: fkByColumn.get(name)
+    };
+  });
+  return { table, columns, indexes };
+}
+function parseSqliteCheckEnum(ddl, column) {
+  if (!ddl)
+    return;
+  const re = new RegExp(`(?:"${column}"|\`${column}\`|\\b${column}\\b)\\s+IN\\s*\\(([^)]*)\\)`, "i");
+  const m = ddl.match(re);
+  if (!m)
+    return;
+  const values = m[1].split(",").map((s) => s.trim().replace(/^'(.*)'$/s, "$1").replace(/''/g, "'")).filter((s) => s.length > 0);
+  return values.length > 0 ? values : undefined;
+}
+function normalizeRawDefault(raw2) {
+  if (typeof raw2 === "number" || typeof raw2 === "boolean")
+    return raw2;
+  return String(raw2);
+}
+async function buildPgTable(qb, table) {
+  const colRows = await qb.unsafe(`SELECT c.column_name, c.data_type, c.udt_name, c.is_nullable, c.column_default, c.character_maximum_length,
+      (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]);
+  const idxRows = await qb.unsafe(`SELECT i.relname AS index_name, ix.indisunique AS is_unique, ix.indisprimary AS is_primary,
+            a.attname AS column_name, array_position(ix.indkey, a.attnum) AS ord,
+            pg_get_expr(ix.indpred, ix.indrelid) AS where_clause
+    FROM pg_class t
+      JOIN pg_index ix ON t.oid = ix.indrelid
+      JOIN pg_class i ON i.oid = ix.indexrelid
+      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+    WHERE t.relname = $1 AND t.relkind = 'r'
+    ORDER BY i.relname, ord`, [table]);
+  const fkRows = await qb.unsafe(`SELECT kcu.column_name, ccu.table_name AS ref_table, ccu.column_name AS ref_column,
+            rc.delete_rule, rc.update_rule
+    FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu ON kcu.constraint_name = tc.constraint_name
+      JOIN information_schema.constraint_column_usage ccu ON ccu.constraint_name = tc.constraint_name
+      JOIN information_schema.referential_constraints rc ON rc.constraint_name = tc.constraint_name
+    WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = $1 AND tc.table_schema = 'public'`, [table]);
+  const fkByColumn = new Map;
+  for (const fk of fkRows) {
+    fkByColumn.set(String(fk.column_name), {
+      table: String(fk.ref_table),
+      column: String(fk.ref_column ?? "id"),
+      onDelete: asAction(fk.delete_rule),
+      onUpdate: asAction(fk.update_rule)
+    });
+  }
+  const { indexes, uniqueColumns } = groupPhysicalIndexes(table, idxRows.map((r) => ({
+    indexName: String(r.index_name),
+    isUnique: r.is_unique === true || r.is_unique === "t",
+    isPrimary: r.is_primary === true || r.is_primary === "t",
+    column: String(r.column_name),
+    where: r.where_clause ? String(r.where_clause) : undefined
+  })));
+  const columns = colRows.map((r) => {
+    const name = String(r.column_name);
+    const isPrimaryKey = Number(r.is_pk) > 0;
+    const rawDefault = r.column_default == null ? null : String(r.column_default);
+    const isSerial = rawDefault != null && /nextval\(/i.test(rawDefault);
+    const hasDefault = rawDefault != null && !isSerial;
+    return {
+      name,
+      type: sqlTypeToNormalized(String(r.data_type ?? r.udt_name ?? ""), "postgres"),
+      isPrimaryKey,
+      isUnique: uniqueColumns.has(name),
+      isNullable: isPrimaryKey ? false : String(r.is_nullable).toUpperCase() === "YES",
+      hasDefault,
+      defaultValue: hasDefault ? normalizeRawDefault(rawDefault) : undefined,
+      references: fkByColumn.get(name)
+    };
+  });
+  return { table, columns, indexes };
+}
+async function buildMysqlTable(qb, table) {
+  const colRows = await qb.unsafe(`SELECT column_name, data_type, column_type, is_nullable, column_default, column_key
+    FROM information_schema.columns
+    WHERE table_name = ? AND table_schema = DATABASE()
+    ORDER BY ordinal_position`, [table]);
+  const idxRows = await qb.unsafe(`SELECT index_name, non_unique, seq_in_index, column_name
+    FROM information_schema.statistics
+    WHERE table_name = ? AND table_schema = DATABASE()
+    ORDER BY index_name, seq_in_index`, [table]);
+  const fkRows = await qb.unsafe(`SELECT kcu.column_name, kcu.referenced_table_name AS ref_table, kcu.referenced_column_name AS ref_column,
+            rc.delete_rule, rc.update_rule
+    FROM information_schema.key_column_usage kcu
+      JOIN information_schema.referential_constraints rc
+        ON rc.constraint_name = kcu.constraint_name AND rc.constraint_schema = kcu.table_schema
+    WHERE kcu.table_name = ? AND kcu.table_schema = DATABASE() AND kcu.referenced_table_name IS NOT NULL`, [table]);
+  const fkByColumn = new Map;
+  for (const fk of fkRows) {
+    fkByColumn.set(String(fk.column_name ?? fk.COLUMN_NAME), {
+      table: String(fk.ref_table ?? fk.REF_TABLE),
+      column: String(fk.ref_column ?? fk.REF_COLUMN ?? "id"),
+      onDelete: asAction(fk.delete_rule ?? fk.DELETE_RULE),
+      onUpdate: asAction(fk.update_rule ?? fk.UPDATE_RULE)
+    });
+  }
+  const { indexes, uniqueColumns } = groupPhysicalIndexes(table, idxRows.map((r) => ({
+    indexName: String(r.index_name ?? r.INDEX_NAME),
+    isUnique: Number(r.non_unique ?? r.NON_UNIQUE) === 0,
+    isPrimary: String(r.index_name ?? r.INDEX_NAME).toUpperCase() === "PRIMARY",
+    column: String(r.column_name ?? r.COLUMN_NAME)
+  })));
+  const columns = colRows.map((r) => {
+    const name = String(r.column_name ?? r.COLUMN_NAME);
+    const columnType = String(r.column_type ?? r.COLUMN_TYPE ?? "");
+    const enumValues = parseMysqlEnum(columnType);
+    const key = String(r.column_key ?? r.COLUMN_KEY ?? "").toUpperCase();
+    const isPrimaryKey = key === "PRI";
+    const rawDefault = r.column_default ?? r.COLUMN_DEFAULT;
+    const hasDefault = rawDefault != null;
+    return {
+      name,
+      type: sqlTypeToNormalized(String(r.data_type ?? r.DATA_TYPE ?? columnType), "mysql", { enumValues }),
+      isPrimaryKey,
+      isUnique: uniqueColumns.has(name),
+      isNullable: isPrimaryKey ? false : String(r.is_nullable ?? r.IS_NULLABLE).toUpperCase() === "YES",
+      hasDefault,
+      defaultValue: hasDefault ? normalizeRawDefault(rawDefault) : undefined,
+      enumValues,
+      references: fkByColumn.get(name)
+    };
+  });
+  return { table, columns, indexes };
+}
+function parseMysqlEnum(columnType) {
+  const m = columnType.match(/^enum\((.*)\)$/i);
+  if (!m)
+    return;
+  return m[1].split(",").map((s) => s.trim().replace(/^'(.*)'$/s, "$1").replace(/''/g, "'")).filter((s) => s.length > 0);
+}
+function groupPhysicalIndexes(table, rows) {
+  const byName = new Map;
+  for (const r of rows) {
+    if (r.isPrimary)
+      continue;
+    const entry = byName.get(r.indexName) ?? { isUnique: r.isUnique, isPrimary: r.isPrimary, columns: [], where: r.where };
+    entry.columns.push(r.column);
+    byName.set(r.indexName, entry);
+  }
+  const indexes = [];
+  const uniqueColumns = new Set;
+  for (const [physName, entry] of byName) {
+    if (entry.columns.length === 0)
+      continue;
+    if (entry.isUnique && entry.columns.length === 1)
+      uniqueColumns.add(entry.columns[0]);
+    indexes.push({
+      name: stripIndexPrefix(physName, table),
+      columns: entry.columns,
+      type: entry.isUnique ? "unique" : "index",
+      where: entry.where
+    });
+  }
+  return { indexes, uniqueColumns };
+}
+async function buildPlanFromDatabase(dialect, opts = {}) {
+  const d = dialect || config5.dialect || "postgres";
+  const qb = createQueryBuilder();
+  const allTables = opts.tables?.length ? opts.tables : await listTables(qb, d);
+  const tables = allTables.filter((t) => t !== "migrations");
+  const out = [];
+  for (const table of tables) {
+    let plan;
+    if (d === "sqlite")
+      plan = await buildSqliteTable(qb, table);
+    else if (d === "postgres")
+      plan = await buildPgTable(qb, table);
+    else
+      plan = await buildMysqlTable(qb, table);
+    if (plan.columns.length > 0)
+      out.push(plan);
+  }
+  return { dialect: d, tables: out };
+}
 var init_introspect_db = __esm(() => {
   init_config();
   init_src2();
@@ -17696,6 +17971,15 @@ class MySQLDriver {
     }
     return `ALTER TABLE ${this.quoteIdentifier(tableName)} MODIFY COLUMN ${parts.join(" ")};`;
   }
+  renameColumn(tableName, from, to) {
+    return `ALTER TABLE ${this.quoteIdentifier(tableName)} RENAME COLUMN ${this.quoteIdentifier(from)} TO ${this.quoteIdentifier(to)};`;
+  }
+  renameTable(from, to) {
+    return `RENAME TABLE ${this.quoteIdentifier(from)} TO ${this.quoteIdentifier(to)};`;
+  }
+  rebuildTable() {
+    throw new Error("[migrations] rebuildTable is only implemented for SQLite; MySQL uses in-place ALTER.");
+  }
   dropTable(tableName) {
     return `DROP TABLE IF EXISTS ${this.quoteIdentifier(tableName)}`;
   }
@@ -17858,6 +18142,15 @@ class PostgresDriver {
     const typeSql = this.getColumnType(column);
     return `ALTER TABLE ${this.quoteIdentifier(tableName)} ALTER COLUMN ${this.quoteIdentifier(column.name)} TYPE ${typeSql} USING ${this.quoteIdentifier(column.name)}::${typeSql};`;
   }
+  renameColumn(tableName, from, to) {
+    return `ALTER TABLE ${this.quoteIdentifier(tableName)} RENAME COLUMN ${this.quoteIdentifier(from)} TO ${this.quoteIdentifier(to)};`;
+  }
+  renameTable(from, to) {
+    return `ALTER TABLE ${this.quoteIdentifier(from)} RENAME TO ${this.quoteIdentifier(to)};`;
+  }
+  rebuildTable() {
+    throw new Error("[migrations] rebuildTable is only implemented for SQLite; Postgres uses in-place ALTER.");
+  }
   dropTable(tableName) {
     return `DROP TABLE IF EXISTS ${this.quoteIdentifier(tableName)} CASCADE`;
   }
@@ -18005,7 +18298,42 @@ class SQLiteDriver {
     return `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD COLUMN ${parts.join(" ")};`;
   }
   modifyColumn(tableName, column) {
-    return `-- SQLite does not support ALTER COLUMN. Manual table recreation needed to change ${this.quoteIdentifier(tableName)}.${this.quoteIdentifier(column.name)} type`;
+    return `-- SQLite does not support ALTER COLUMN; a table rebuild is required to change ${this.quoteIdentifier(tableName)}.${this.quoteIdentifier(column.name)}`;
+  }
+  renameColumn(tableName, from, to) {
+    return `ALTER TABLE ${this.quoteIdentifier(tableName)} RENAME COLUMN ${this.quoteIdentifier(from)} TO ${this.quoteIdentifier(to)};`;
+  }
+  renameTable(from, to) {
+    return `ALTER TABLE ${this.quoteIdentifier(from)} RENAME TO ${this.quoteIdentifier(to)};`;
+  }
+  rebuildTable(spec) {
+    const { target, tempName, columnSource } = spec;
+    const q = (id) => this.quoteIdentifier(id);
+    const columnsSql = target.columns.map((c) => this.renderColumn(c)).join(`,
+  `);
+    const createTmp = `CREATE TABLE ${q(tempName)} (
+  ${columnsSql}
+);`;
+    const carried = target.columns.map((c) => c.name).filter((name) => columnSource[name] !== undefined);
+    const statements = [
+      "PRAGMA foreign_keys=OFF;",
+      "BEGIN;",
+      createTmp
+    ];
+    if (carried.length > 0) {
+      const insertCols = carried.map(q).join(", ");
+      const selectCols = carried.map((name) => q(columnSource[name])).join(", ");
+      statements.push(`INSERT INTO ${q(tempName)} (${insertCols}) SELECT ${selectCols} FROM ${q(target.table)};`);
+    }
+    statements.push(`DROP TABLE ${q(target.table)};`);
+    statements.push(`ALTER TABLE ${q(tempName)} RENAME TO ${q(target.table)};`);
+    for (const idx of target.indexes)
+      statements.push(this.createIndex(target.table, idx));
+    statements.push("PRAGMA foreign_key_check;");
+    statements.push("COMMIT;");
+    statements.push("PRAGMA foreign_keys=ON;");
+    return statements.join(`
+`);
   }
   dropTable(tableName) {
     return `DROP TABLE IF EXISTS ${this.quoteIdentifier(tableName)}`;
@@ -18172,6 +18500,19 @@ async function generateMigration(dir, opts = {}) {
           }
         } catch {}
       }
+      if (!previous || opts.fromDb) {
+        try {
+          const livePlan = await buildPlanFromDatabase(dialect);
+          const modelTables = new Set(plan.tables.map((t) => t.table));
+          const scoped = livePlan.tables.filter((t) => modelTables.has(t.table));
+          if (scoped.length > 0) {
+            previous = { dialect: livePlan.dialect, tables: scoped };
+            info(`-- No snapshot; reconciling against live database (${scoped.length} matching table${scoped.length === 1 ? "" : "s"})`);
+          }
+        } catch (err) {
+          info(`-- Could not introspect live database, treating as no previous state: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
       if (!previous) {
         info("-- No previous snapshot found, generating full migration");
       }
@@ -18179,7 +18520,9 @@ async function generateMigration(dir, opts = {}) {
   } else {
     info("-- Full migration requested, ignoring any previous state");
   }
-  const sqlStatements = opts.full ? generateSql(plan) : generateDiffSql(previous, plan);
+  const diff = opts.full ? { statements: generateSql(plan, { dryRun: opts.dryRun }), operations: plan.tables.map((t) => ({ kind: "create_table", table: t.table, destructive: false, sql: "" })) } : generateDiffOperations(previous, plan, { applyRenames: opts.applyRenames, dryRun: opts.dryRun });
+  const sqlStatements = diff.statements;
+  const operations = diff.operations;
   const sql = sqlStatements.join(`
 `);
   const hasChanges = sqlStatements.some((stmt) => /\b(?:CREATE|ALTER|DROP)\b/i.test(stmt));
@@ -18198,8 +18541,9 @@ async function generateMigration(dir, opts = {}) {
       throw err;
     }
   }
-  savePlanSnapshot(workspaceRoot, dialect, plan);
-  return { sql, sqlStatements, hasChanges, plan };
+  if (!opts.dryRun)
+    savePlanSnapshot(workspaceRoot, dialect, plan);
+  return { sql, sqlStatements, hasChanges, plan, operations };
 }
 async function executeMigration(dir) {
   if (!dir) {
@@ -18448,6 +18792,7 @@ var init_migrate = __esm(() => {
   init_db();
   init_drivers();
   init_src2();
+  init_introspect_db();
 });
 
 // src/actions/migrate-generate.ts
@@ -24621,8 +24966,45 @@ function resolveRelation(definition, relationName) {
       pivotTimestamps: Boolean(config6?.pivot?.timestamps)
     };
   }
+  const resolveThrough = (field, type) => {
+    if (!field || typeof field !== "object" || Array.isArray(field))
+      return null;
+    const entry = field[relationName] ?? field[Object.keys(field).find((k2) => k2.toLowerCase() === relationName.toLowerCase()) ?? ""];
+    if (!entry || typeof entry !== "object")
+      return null;
+    const throughModelName = entry.through;
+    const targetModelName = entry.target;
+    if (!throughModelName || !targetModelName)
+      return null;
+    const throughModel = getModelFromRegistry(throughModelName);
+    const throughDef = throughModel?.getDefinition?.() || throughModel?.definition;
+    const throughTable = throughModel?.getTable?.() || throughDef?.table || toTableName(throughModelName);
+    const throughPk = throughDef?.primaryKey || "id";
+    const targetModel = getModelFromRegistry(targetModelName);
+    const targetTable = targetModel?.getTable?.() || toTableName(targetModelName);
+    return {
+      type,
+      relatedModelName: targetModelName,
+      relatedTable: targetTable,
+      foreignKey: `${toSnakeCase(parentName)}_id`,
+      localKey: parentPk,
+      throughTable,
+      throughForeignKey: `${toSnakeCase(parentName)}_id`,
+      throughLocalKey: throughPk,
+      targetForeignKey: `${singularizeWord(throughTable)}_id`
+    };
+  };
+  const hmt = resolveThrough(definition.hasManyThrough, "hasManyThrough");
+  if (hmt)
+    return hmt;
+  const hot = resolveThrough(definition.hasOneThrough, "hasOneThrough");
+  if (hot)
+    return hot;
   return null;
 }
+function singularizeWord(table) {
+  return table.endsWith("s") ? table.slice(0, -1) : table;
+}
 
 class BelongsToManyRelationBuilder {
   _parent;
@@ -25259,6 +25641,40 @@ class ModelQueryBuilder {
           instance.setRelation(relationName, relatedInstances);
         }
       }
+      if (rel.type === "hasManyThrough" || rel.type === "hasOneThrough") {
+        const parentIds = instances.map((i2) => i2.get(pk)).filter((id) => id != null);
+        if (parentIds.length === 0)
+          continue;
+        const throughPk = rel.throughLocalKey || "id";
+        const throughPh = parentIds.map(() => "?").join(", ");
+        const throughRows = await exec.all(`SELECT ${throughPk}, ${rel.throughForeignKey} FROM ${rel.throughTable} WHERE ${rel.throughForeignKey} IN (${throughPh})`, parentIds);
+        if (throughRows.length === 0) {
+          for (const instance of instances)
+            instance.setRelation(relationName, rel.type === "hasManyThrough" ? [] : null);
+          continue;
+        }
+        const throughToParent = new Map;
+        for (const t2 of throughRows)
+          throughToParent.set(t2[throughPk], t2[rel.throughForeignKey]);
+        const throughIds = [...new Set(throughRows.map((t2) => t2[throughPk]))];
+        const targetPh = throughIds.map(() => "?").join(", ");
+        const targetRows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.targetForeignKey} IN (${targetPh})`, throughIds);
+        const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
+        const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
+        const byParent = new Map;
+        for (const row of targetRows) {
+          const parentVal = throughToParent.get(row[rel.targetForeignKey]);
+          if (parentVal == null)
+            continue;
+          if (!byParent.has(parentVal))
+            byParent.set(parentVal, []);
+          byParent.get(parentVal).push(new ModelInstance(relDef, row));
+        }
+        for (const instance of instances) {
+          const group = byParent.get(instance.get(pk)) || [];
+          instance.setRelation(relationName, rel.type === "hasManyThrough" ? group : group[0] ?? null);
+        }
+      }
     }
   }
   async get() {
@@ -27731,11 +28147,12 @@ function buildMigrationPlan2(models, options) {
   }
   return { dialect: options.dialect, tables };
 }
-function generateSql(plan) {
+function generateSql(plan, opts = {}) {
   migrationCounter = 0;
   migrationsCreatedCount = 0;
   migrationsUpdatedCount = 0;
   useDeterministicNames = true;
+  const emit = opts.dryRun ? () => false : createMigrationFile;
   const statements = [];
   const driver = getDialectDriver(plan.dialect);
   for (const t2 of plan.tables) {
@@ -27759,7 +28176,7 @@ function generateSql(plan) {
     const combinedStatement = tableStatements.join(`
 
 `);
-    createMigrationFile(combinedStatement, `create-${t2.table}-table`);
+    emit(combinedStatement, `create-${t2.table}-table`);
   }
   for (const t2 of plan.tables) {
     for (const c2 of t2.columns) {
@@ -27768,7 +28185,7 @@ function generateSql(plan) {
         if (!alterTableStatement)
           continue;
         statements.push(alterTableStatement);
-        createMigrationFile(alterTableStatement, `alter-${t2.table}-${c2.name}`);
+        emit(alterTableStatement, `alter-${t2.table}-${c2.name}`);
       }
     }
   }
@@ -27776,7 +28193,7 @@ function generateSql(plan) {
     for (const idx of t2.indexes) {
       const createIndexStatement = driver.createIndex(t2.table, idx);
       statements.push(createIndexStatement);
-      createMigrationFile(createIndexStatement, `create-${idx.name}-index-in-${t2.table}`);
+      emit(createIndexStatement, `create-${idx.name}-index-in-${t2.table}`);
     }
   }
   const totalChanges = migrationsCreatedCount + migrationsUpdatedCount;
@@ -27827,31 +28244,138 @@ function mapColumnsByName(columns) {
     map[c2.name] = c2;
   return map;
 }
-function columnsAreDifferent(col1, col2) {
-  if (col1.type !== col2.type)
+function canonicalStorageType(col, dialect) {
+  if (dialect === "sqlite") {
+    if (col.name.endsWith("_id"))
+      return "INTEGER";
+    switch (col.type) {
+      case "string":
+      case "text":
+      case "date":
+      case "datetime":
+      case "json":
+      case "enum":
+        return "TEXT";
+      case "boolean":
+      case "integer":
+      case "bigint":
+        return "INTEGER";
+      case "float":
+      case "double":
+      case "decimal":
+        return "REAL";
+      default:
+        return "TEXT";
+    }
+  }
+  return col.type;
+}
+function canonicalizeDefault(col) {
+  if (!col.hasDefault || col.defaultValue === undefined)
+    return;
+  const dv = col.defaultValue;
+  if (dv instanceof Date)
+    return dv.toISOString();
+  if (typeof dv === "boolean")
+    return dv ? "1" : "0";
+  if (typeof dv === "bigint" || typeof dv === "number")
+    return String(dv);
+  let s2 = String(dv).trim();
+  s2 = s2.replace(/::[\w ]+$/i, "").trim();
+  if (s2.startsWith("'") && s2.endsWith("'") || s2.startsWith('"') && s2.endsWith('"'))
+    s2 = s2.slice(1, -1);
+  const upper = s2.toUpperCase();
+  const sqlFns = ["CURRENT_TIMESTAMP", "NOW()", "CURRENT_DATE", "CURRENT_TIME", "NULL", "TRUE", "FALSE"];
+  if (sqlFns.includes(upper))
+    return upper === "NOW()" ? "CURRENT_TIMESTAMP" : upper;
+  if (col.type === "boolean") {
+    if (/^(?:1|t|true|yes)$/i.test(s2))
+      return "1";
+    if (/^(?:0|f|false|no)$/i.test(s2))
+      return "0";
+  }
+  if (/^-?\d+(?:\.\d+)?$/.test(s2))
+    return String(Number(s2));
+  return s2;
+}
+function columnsAreDifferent(col1, col2, dialect) {
+  if (canonicalStorageType(col1, dialect) !== canonicalStorageType(col2, dialect))
     return true;
   if (col1.isNullable !== col2.isNullable)
     return true;
   if (col1.hasDefault !== col2.hasDefault)
     return true;
-  if (col1.defaultValue !== col2.defaultValue)
+  if (canonicalizeDefault(col1) !== canonicalizeDefault(col2))
     return true;
   if (col1.isUnique !== col2.isUnique)
     return true;
   if (col1.type === "enum" && col2.type === "enum") {
-    const enum1 = (col1.enumValues || []).sort().join(",");
-    const enum2 = (col2.enumValues || []).sort().join(",");
+    const enum1 = (col1.enumValues || []).slice().sort().join(",");
+    const enum2 = (col2.enumValues || []).slice().sort().join(",");
     if (enum1 !== enum2)
       return true;
   }
   return false;
 }
+function columnSignature(col, dialect) {
+  return JSON.stringify([
+    canonicalStorageType(col, dialect),
+    col.isPrimaryKey,
+    col.isUnique,
+    col.isNullable,
+    col.hasDefault,
+    canonicalizeDefault(col) ?? null,
+    (col.enumValues ?? []).slice().sort(),
+    col.references ? [col.references.table, col.references.column, col.references.onDelete ?? null, col.references.onUpdate ?? null] : null
+  ]);
+}
+function detectColumnRenames(prevCols, currCols, dialect) {
+  const removed = Object.keys(prevCols).filter((n2) => !currCols[n2]);
+  const added = Object.keys(currCols).filter((n2) => !prevCols[n2]);
+  const sigRemoved = new Map;
+  const sigAdded = new Map;
+  for (const n2 of removed) {
+    const s2 = columnSignature(prevCols[n2], dialect);
+    const list = sigRemoved.get(s2) ?? [];
+    list.push(n2);
+    sigRemoved.set(s2, list);
+  }
+  for (const n2 of added) {
+    const s2 = columnSignature(currCols[n2], dialect);
+    const list = sigAdded.get(s2) ?? [];
+    list.push(n2);
+    sigAdded.set(s2, list);
+  }
+  const renames = [];
+  const usedRemoved = new Set;
+  const usedAdded = new Set;
+  for (const [sig, rem] of sigRemoved) {
+    const add = sigAdded.get(sig);
+    if (rem.length === 1 && add && add.length === 1) {
+      renames.push({ from: rem[0], to: add[0] });
+      usedRemoved.add(rem[0]);
+      usedAdded.add(add[0]);
+    }
+  }
+  return {
+    renames,
+    removed: removed.filter((n2) => !usedRemoved.has(n2)),
+    added: added.filter((n2) => !usedAdded.has(n2))
+  };
+}
+function isColumnConstrained(table, columnName) {
+  const col = table.columns.find((c2) => c2.name === columnName);
+  if (col && (col.isPrimaryKey || col.isUnique || col.references))
+    return true;
+  return table.indexes.some((idx) => idx.columns.includes(columnName));
+}
 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;
+  const act = (a2) => (a2 ?? "no action").toLowerCase();
+  return r1.table !== r2.table || r1.column !== r2.column || act(r1.onDelete) !== act(r2.onDelete) || act(r1.onUpdate) !== act(r2.onUpdate);
 }
 function mapIndexesByKey(indexes) {
   const map = {};
@@ -27861,22 +28385,35 @@ function mapIndexesByKey(indexes) {
   }
   return map;
 }
-function generateDiffSql(previous, next) {
-  if (!previous || previous.dialect !== next.dialect)
-    return generateSql(next);
+function generateDiffOperations(previous, next, opts = {}) {
+  if (!previous || previous.dialect !== next.dialect) {
+    const statements2 = generateSql(next, { dryRun: opts.dryRun });
+    const operations2 = next.tables.map((t2) => ({
+      kind: "create_table",
+      table: t2.table,
+      destructive: false,
+      sql: ""
+    }));
+    return { statements: statements2, operations: operations2 };
+  }
+  const applyRenames = opts.applyRenames !== false;
+  const emit = opts.dryRun ? () => false : createMigrationFile;
   migrationCounter = 0;
   migrationsCreatedCount = 0;
   migrationsUpdatedCount = 0;
   useDeterministicNames = false;
   const chunks = [];
+  const operations = [];
   const driver = getDialectDriver(next.dialect);
+  const dialect = next.dialect;
   const prevTables = mapTablesByName(previous.tables);
   const nextTables = mapTablesByName(next.tables);
   for (const tableName of Object.keys(prevTables)) {
     if (!nextTables[tableName]) {
       const dropTableStatement = driver.dropTable(tableName);
       chunks.push(dropTableStatement);
-      createMigrationFile(dropTableStatement, `drop-${tableName}-table`);
+      operations.push({ kind: "drop_table", table: tableName, destructive: true, sql: dropTableStatement });
+      emit(dropTableStatement, `drop-${tableName}-table`);
       info2(`-- Detected dropped table: ${tableName}`);
     }
   }
@@ -27900,10 +28437,11 @@ function generateDiffSql(previous, next) {
       const createTableStatement = driver.createTable(t2);
       tableStatements.push(createTableStatement);
       chunks.push(...tableStatements);
+      operations.push({ kind: "create_table", table: t2.table, destructive: false, sql: createTableStatement });
       const combinedStatement = tableStatements.join(`
 
 `);
-      createMigrationFile(combinedStatement, `create-${t2.table}-table`);
+      emit(combinedStatement, `create-${t2.table}-table`);
     }
   }
   for (const tableName of Object.keys(nextTables)) {
@@ -27912,7 +28450,8 @@ function generateDiffSql(previous, next) {
       for (const idx of t2.indexes) {
         const createIndexStatement = driver.createIndex(t2.table, idx);
         chunks.push(createIndexStatement);
-        createMigrationFile(createIndexStatement, `create-${idx.name}-index-in-${t2.table}`);
+        operations.push({ kind: "create_index", table: t2.table, column: idx.name, destructive: false, sql: createIndexStatement });
+        emit(createIndexStatement, `create-${idx.name}-index-in-${t2.table}`);
       }
     }
   }
@@ -27925,7 +28464,8 @@ function generateDiffSql(previous, next) {
           if (!alterTableStatement)
             continue;
           chunks.push(alterTableStatement);
-          createMigrationFile(alterTableStatement, `alter-${t2.table}-${c2.name}`);
+          operations.push({ kind: "add_foreign_key", table: t2.table, column: c2.name, destructive: false, sql: alterTableStatement });
+          emit(alterTableStatement, `alter-${t2.table}-${c2.name}`);
         }
       }
     }
@@ -27947,7 +28487,8 @@ function generateDiffSql(previous, next) {
             const createEnumStatement = driver.createEnumType(enumTypeName, c2.enumValues);
             if (createEnumStatement) {
               chunks.push(createEnumStatement);
-              createMigrationFile(createEnumStatement, `create-${enumTypeName}-enum`);
+              operations.push({ kind: "create_enum", table: curr.table, column: c2.name, destructive: false, sql: createEnumStatement });
+              emit(createEnumStatement, `create-${enumTypeName}-enum`);
             }
             enumTypes.add(enumTypeName);
           }
@@ -27964,6 +28505,52 @@ function generateDiffSql(previous, next) {
     const currCols = mapColumnsByName(curr.columns);
     const prevIdx = mapIndexesByKey(prev.indexes);
     const currIdx = mapIndexesByKey(curr.indexes);
+    let renames = [];
+    let removedCols = Object.keys(prevCols).filter((n2) => !currCols[n2]);
+    let addedCols = Object.keys(currCols).filter((n2) => !prevCols[n2]);
+    if (applyRenames) {
+      const detected = detectColumnRenames(prevCols, currCols, dialect);
+      renames = detected.renames;
+      removedCols = detected.removed;
+      addedCols = detected.added;
+    }
+    const modifiedCols = Object.keys(currCols).filter((n2) => prevCols[n2] && columnsAreDifferent(prevCols[n2], currCols[n2], dialect));
+    const fkChangedCols = Object.keys(currCols).filter((n2) => prevCols[n2] && referencesAreDifferent(prevCols[n2].references, currCols[n2].references));
+    if (dialect === "sqlite") {
+      const needsRebuild = modifiedCols.length > 0 || fkChangedCols.length > 0 || removedCols.some((name) => isColumnConstrained(prev, name));
+      if (needsRebuild) {
+        const columnSource = {};
+        const renameTo = new Map(renames.map((r2) => [r2.to, r2.from]));
+        for (const c2 of curr.columns) {
+          if (prevCols[c2.name])
+            columnSource[c2.name] = c2.name;
+          else if (renameTo.has(c2.name))
+            columnSource[c2.name] = renameTo.get(c2.name);
+        }
+        let tempName = `_qb_tmp_${curr.table}`;
+        let guard = 0;
+        while ((prevTables[tempName] || nextTables[tempName]) && guard < 100) {
+          guard += 1;
+          tempName = `_qb_tmp_${curr.table}_${guard}`;
+        }
+        const rebuildStatement = driver.rebuildTable({ target: curr, tempName, columnSource });
+        chunks.push(rebuildStatement);
+        const typeChanged = modifiedCols.some((n2) => prevCols[n2].type !== currCols[n2].type);
+        operations.push({
+          kind: "rebuild_table",
+          table: curr.table,
+          destructive: removedCols.length > 0 || typeChanged,
+          sql: rebuildStatement
+        });
+        for (const r2 of renames)
+          operations.push({ kind: "rename_column", table: curr.table, from: r2.from, to: r2.to, destructive: false, confidence: "high", sql: rebuildStatement });
+        for (const name of removedCols)
+          operations.push({ kind: "drop_column", table: curr.table, column: name, destructive: true, sql: rebuildStatement });
+        info2(`-- Detected SQLite table rebuild required: ${curr.table}`);
+        emit(rebuildStatement, `alter-${curr.table}-table`);
+        continue;
+      }
+    }
     const tableChanges = [];
     let hasChanges = false;
     for (const key of Object.keys(prevIdx)) {
@@ -27972,51 +28559,70 @@ function generateDiffSql(previous, next) {
         const dropIndexStatement = driver.dropIndex(curr.table, idx.name);
         tableChanges.push(dropIndexStatement);
         chunks.push(dropIndexStatement);
+        operations.push({ kind: "drop_index", table: curr.table, column: idx.name, destructive: false, sql: dropIndexStatement });
         info2(`-- Detected dropped index: ${idx.name} from ${curr.table}`);
         hasChanges = true;
       }
     }
-    for (const colName of Object.keys(prevCols)) {
-      if (!currCols[colName]) {
-        const dropColumnStatement = driver.dropColumn(curr.table, colName);
-        tableChanges.push(dropColumnStatement);
-        chunks.push(dropColumnStatement);
-        info2(`-- Detected dropped column: ${curr.table}.${colName}`);
-        hasChanges = true;
-      }
-    }
-    for (const colName of Object.keys(currCols)) {
-      if (prevCols[colName] && currCols[colName]) {
-        const prevCol = prevCols[colName];
-        const currCol = currCols[colName];
-        if (columnsAreDifferent(prevCol, currCol)) {
-          const modifyColumnStatement = driver.modifyColumn(curr.table, currCol);
-          tableChanges.push(modifyColumnStatement);
-          chunks.push(modifyColumnStatement);
-          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 r2 of renames) {
+      const renameStatement = driver.renameColumn(curr.table, r2.from, r2.to);
+      tableChanges.push(renameStatement);
+      chunks.push(renameStatement);
+      operations.push({ kind: "rename_column", table: curr.table, from: r2.from, to: r2.to, destructive: false, confidence: "high", sql: renameStatement });
+      info2(`-- Detected renamed column: ${curr.table}.${r2.from} -> ${r2.to}`);
+      hasChanges = true;
+    }
+    for (const colName of removedCols) {
+      const dropColumnStatement = driver.dropColumn(curr.table, colName);
+      tableChanges.push(dropColumnStatement);
+      chunks.push(dropColumnStatement);
+      operations.push({ kind: "drop_column", table: curr.table, column: colName, destructive: true, sql: dropColumnStatement });
+      info2(`-- Detected dropped column: ${curr.table}.${colName}`);
+      hasChanges = true;
+    }
+    for (const colName of modifiedCols) {
+      const prevCol = prevCols[colName];
+      const currCol = currCols[colName];
+      const modifyColumnStatement = driver.modifyColumn(curr.table, currCol);
+      tableChanges.push(modifyColumnStatement);
+      chunks.push(modifyColumnStatement);
+      operations.push({
+        kind: "modify_column",
+        table: curr.table,
+        column: colName,
+        destructive: prevCol.type !== currCol.type,
+        sql: modifyColumnStatement
+      });
+      info2(`-- Detected column change: ${curr.table}.${colName} (${prevCol.type} -> ${currCol.type})`);
+      hasChanges = true;
     }
-    for (const colName of Object.keys(currCols)) {
-      if (!prevCols[colName]) {
-        const c2 = currCols[colName];
-        const addColumnStatement = driver.addColumn(curr.table, c2);
-        tableChanges.push(addColumnStatement);
-        chunks.push(addColumnStatement);
-        info2(`-- Detected new column: ${curr.table}.${c2.name}`);
-        hasChanges = true;
-        if (c2.references) {
-          const addFkStatement = driver.addForeignKey(curr.table, c2.name, c2.references.table, c2.references.column, c2.references.onDelete, c2.references.onUpdate);
+    for (const colName of fkChangedCols) {
+      const currCol = currCols[colName];
+      if (!currCol.references)
+        continue;
+      const addFkStatement = driver.addForeignKey(curr.table, currCol.name, currCol.references.table, currCol.references.column, currCol.references.onDelete, currCol.references.onUpdate);
+      if (!addFkStatement)
+        continue;
+      tableChanges.push(addFkStatement);
+      chunks.push(addFkStatement);
+      operations.push({ kind: "add_foreign_key", table: curr.table, column: colName, destructive: false, sql: addFkStatement });
+      info2(`-- Detected foreign-key change: ${curr.table}.${colName} -> ${currCol.references.table}(${currCol.references.column})`);
+      hasChanges = true;
+    }
+    for (const colName of addedCols) {
+      const c2 = currCols[colName];
+      const addColumnStatement = driver.addColumn(curr.table, c2);
+      tableChanges.push(addColumnStatement);
+      chunks.push(addColumnStatement);
+      operations.push({ kind: "add_column", table: curr.table, column: c2.name, destructive: false, sql: addColumnStatement });
+      info2(`-- Detected new column: ${curr.table}.${c2.name}`);
+      hasChanges = true;
+      if (c2.references) {
+        const addFkStatement = driver.addForeignKey(curr.table, c2.name, c2.references.table, c2.references.column, c2.references.onDelete, c2.references.onUpdate);
+        if (addFkStatement) {
           tableChanges.push(addFkStatement);
           chunks.push(addFkStatement);
+          operations.push({ kind: "add_foreign_key", table: curr.table, column: c2.name, destructive: false, sql: addFkStatement });
         }
       }
     }
@@ -28026,6 +28632,7 @@ function generateDiffSql(previous, next) {
         const createIndexStatement = driver.createIndex(curr.table, idx);
         tableChanges.push(createIndexStatement);
         chunks.push(createIndexStatement);
+        operations.push({ kind: "create_index", table: curr.table, column: idx.name, destructive: false, sql: createIndexStatement });
         info2(`-- Detected new index: ${idx.name} in ${curr.table}`);
         hasChanges = true;
       }
@@ -28034,7 +28641,7 @@ function generateDiffSql(previous, next) {
       const combinedStatement = tableChanges.join(`
 
 `);
-      createMigrationFile(combinedStatement, `alter-${curr.table}-table`);
+      emit(combinedStatement, `alter-${curr.table}-table`);
     }
   }
   const totalChanges = migrationsCreatedCount + migrationsUpdatedCount;
@@ -28048,9 +28655,11 @@ function generateDiffSql(previous, next) {
       parts.push(`${migrationsUpdatedCount} updated`);
     info2(`-- Migration files: ${parts.join(", ")}`);
   }
-  if (chunks.length === 0)
-    return ["-- No changes detected"];
-  return chunks;
+  const statements = chunks.length === 0 ? ["-- No changes detected"] : chunks;
+  return { statements, operations };
+}
+function generateDiffSql(previous, next, opts = {}) {
+  return generateDiffOperations(previous, next, opts).statements;
 }
 var migrationCounter = 0, migrationsCreatedCount = 0, migrationsUpdatedCount = 0, useDeterministicNames = true;
 var init_migrations = __esm(() => {
@@ -28166,6 +28775,7 @@ export {
   generateMigration,
   generateDiffSqlString,
   generateDiffSql,
+  generateDiffOperations,
   relationDiagram as generateDiagram,
   generateAccessPatterns,
   freshDatabase,
@@ -28211,6 +28821,8 @@ export {
   clearQueryCache,
   clearModelRegistry,
   checkSchema,
+  canonicalizeDefault,
+  canonicalStorageType,
   cacheStats,
   cacheConfig,
   cacheClear,