@stacksjs/database 0.70.87 → 0.70.90

package/dist/migration-lock.js

@@ -0,0 +1,143 @@
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+import { closeSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import process from "node:process";
+import { userDatabasePath } from "@stacksjs/path";
+const DEFAULT_TIMEOUT_MS = 30000, INITIAL_BACKOFF_MS = 100, MAX_BACKOFF_MS = 2000, STALE_LOCK_MS = 60000, LOCK_NAME = "stacks_migrations";
+export async function acquireMigrationLock(dialect, adminDb, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (dialect !== "sqlite" && dialect !== "postgres" && dialect !== "mysql")
+    throw Error(`[migration-lock] unknown dialect: ${String(dialect)}`);
+  if (dialect === "sqlite")
+    return acquireSqliteLock(opts.sqliteLockPath, timeoutMs);
+  if (!adminDb)
+    throw Error(`[migration-lock] ${dialect} requires a database connection to acquire the lock`);
+  if (dialect === "postgres")
+    return acquirePostgresLock(adminDb, timeoutMs);
+  return acquireMySqlLock(adminDb, timeoutMs);
+}
+function lockKeysForPostgres() {
+  const hash = createHash("sha256").update(LOCK_NAME).digest(), key1 = hash.readInt32BE(0), key2 = hash.readInt32BE(4);
+  return { key1, key2 };
+}
+async function acquirePostgresLock(adminDb, timeoutMs) {
+  const { key1, key2 } = lockKeysForPostgres(), start = Date.now();
+  let backoff = INITIAL_BACKOFF_MS;
+  while (!0) {
+    const result = await adminDb.unsafe(`SELECT pg_try_advisory_lock(${key1}, ${key2}) AS acquired`);
+    if (extractFirstBool(result, "acquired"))
+      return {
+        release: async () => {
+          try {
+            await adminDb.unsafe(`SELECT pg_advisory_unlock(${key1}, ${key2})`);
+          } catch {}
+        }
+      };
+    if (Date.now() - start >= timeoutMs)
+      throw Error("[migration-lock] another migration is in progress \u2014 could not acquire postgres advisory lock within timeout");
+    await sleepWithJitter(backoff);
+    backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+  }
+}
+async function acquireMySqlLock(adminDb, timeoutMs) {
+  const start = Date.now();
+  let backoff = INITIAL_BACKOFF_MS;
+  while (!0) {
+    const result = await adminDb.unsafe(`SELECT GET_LOCK('${LOCK_NAME}', 0) AS acquired`);
+    if (extractFirstInt(result, "acquired") === 1)
+      return {
+        release: async () => {
+          try {
+            await adminDb.unsafe(`SELECT RELEASE_LOCK('${LOCK_NAME}')`);
+          } catch {}
+        }
+      };
+    if (Date.now() - start >= timeoutMs)
+      throw Error("[migration-lock] another migration is in progress \u2014 could not acquire MySQL named lock within timeout");
+    await sleepWithJitter(backoff);
+    backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+  }
+}
+function defaultSqliteLockPath() {
+  return userDatabasePath(".migration.lock");
+}
+async function acquireSqliteLock(lockPath, timeoutMs) {
+  const path = lockPath ?? defaultSqliteLockPath(), start = Date.now();
+  let backoff = INITIAL_BACKOFF_MS;
+  while (!0) {
+    if (tryCreateLockFile(path)) {
+      let released = !1;
+      return {
+        release: async () => {
+          if (released)
+            return;
+          released = !0;
+          try {
+            unlinkSync(path);
+          } catch {}
+        }
+      };
+    }
+    reclaimIfStale(path);
+    if (Date.now() - start >= timeoutMs)
+      throw Error(`[migration-lock] another migration is in progress \u2014 lock file ${path} held within timeout`);
+    await sleepWithJitter(backoff);
+    backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+  }
+}
+function tryCreateLockFile(path) {
+  try {
+    const fd = openSync(path, "wx");
+    try {
+      const payload = JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() });
+      writeFileSync(fd, Buffer.from(payload, "utf8"));
+    } finally {
+      closeSync(fd);
+    }
+    return !0;
+  } catch (e) {
+    if (e.code === "EEXIST")
+      return !1;
+    throw e;
+  }
+}
+function reclaimIfStale(path) {
+  try {
+    const st = statSync(path);
+    if (Date.now() - st.mtimeMs > STALE_LOCK_MS)
+      try {
+        unlinkSync(path);
+      } catch {}
+  } catch {}
+}
+function sleepWithJitter(ms) {
+  const jittered = ms * (1 + Math.random() * 0.25);
+  return new Promise((resolve) => setTimeout(resolve, jittered));
+}
+function extractFirstBool(result, column) {
+  const row = pluckFirstRow(result);
+  if (!row)
+    return !1;
+  const value = row[column];
+  return value === !0 || value === 1 || value === "1" || value === "t";
+}
+function extractFirstInt(result, column) {
+  const row = pluckFirstRow(result);
+  if (!row)
+    return null;
+  const value = row[column];
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "string" && /^-?\d+$/.test(value))
+    return Number.parseInt(value, 10);
+  return null;
+}
+function pluckFirstRow(result) {
+  if (!result)
+    return null;
+  if (Array.isArray(result))
+    return result[0];
+  if (typeof result === "object" && "rows" in result && Array.isArray(result.rows))
+    return result.rows[0];
+  return null;
+}

package/dist/migrations.js

@@ -0,0 +1,528 @@
+var {require}=import.meta;import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { log as _log } from "@stacksjs/logging";
+const log = {
+  info: (...args) => typeof _log?.info === "function" ? _log.info(...args) : console.log(...args),
+  success: (msg) => typeof _log?.success === "function" ? _log.success(msg) : console.log(msg),
+  warn: (msg) => typeof _log?.warn === "function" ? _log.warn(msg) : console.warn(msg),
+  error: (...args) => typeof _log?.error === "function" ? _log.error(...args) : console.error(...args),
+  debug: (...args) => typeof _log?.debug === "function" ? _log.debug(...args) : console.debug(...args)
+};
+import { err, handleError, ok } from "@stacksjs/error-handling";
+import { path } from "@stacksjs/path";
+import {
+  createQueryBuilder,
+  executeMigration as qbExecuteMigration,
+  generateMigration as qbGenerateMigration,
+  resetConnection,
+  resetDatabase as qbResetDatabase,
+  setConfig
+} from "@stacksjs/query-builder";
+import { db } from "./utils";
+import { acquireMigrationLock } from "./migration-lock";
+import { env as envVars } from "@stacksjs/env";
+import { getConnectionDefaults } from "./defaults";
+const dbDriver = envVars.DB_CONNECTION || "sqlite", sqliteDefaults = getConnectionDefaults("sqlite", envVars), mysqlDefaults = getConnectionDefaults("mysql", envVars), postgresDefaults = getConnectionDefaults("postgres", envVars), dbConfig = {
+  default: dbDriver,
+  connections: {
+    sqlite: { database: sqliteDefaults.database, prefix: "" },
+    mysql: { name: mysqlDefaults.database, host: mysqlDefaults.host, username: mysqlDefaults.username, password: mysqlDefaults.password, port: mysqlDefaults.port, prefix: "" },
+    postgres: { name: postgresDefaults.database, host: postgresDefaults.host, username: postgresDefaults.username, password: postgresDefaults.password, port: postgresDefaults.port, prefix: "" }
+  }
+};
+function getDriver() {
+  return dbConfig.default || "sqlite";
+}
+function getDialect() {
+  const driver = getDriver();
+  if (driver === "sqlite" || driver === "mysql" || driver === "postgres")
+    return driver;
+  if (driver === "singlestore")
+    return "mysql";
+  if (driver === "dynamodb")
+    throw Error("[database] DB_CONNECTION=dynamodb is not compatible with the SQL migration runner. " + "DynamoDB has no schema-migration concept \u2014 use the entity-style `dynamo.entity(...)` " + "API from @stacksjs/database directly. To run SQL migrations, set DB_CONNECTION to one of: sqlite, mysql, postgres.");
+  throw Error(`[database] Unknown DB_CONNECTION "${driver}". Allowed values: sqlite, mysql, postgres, dynamodb.`);
+}
+function getQbDialect() {
+  return getDriver() === "singlestore" ? "singlestore" : getDialect();
+}
+function configureQueryBuilder() {
+  const dialect = getDialect(), connectionConfig = dbConfig.connections[dialect];
+  setConfig({
+    dialect,
+    verbose: !1,
+    database: {
+      database: connectionConfig?.name || connectionConfig?.database || "stacks",
+      host: connectionConfig?.host || "localhost",
+      port: connectionConfig?.port || (dialect === "postgres" ? 5432 : dialect === "mysql" ? 3306 : 0),
+      username: connectionConfig?.username || "",
+      password: connectionConfig?.password || ""
+    }
+  });
+  resetConnection();
+}
+function prepareMigrationModelsDir() {
+  const userModelsDir = path.userModelsPath();
+  return { modelsDir: userModelsDir, skip: !existsSync(userModelsDir) };
+}
+export function preprocessSqliteMigrations() {
+  const migrationsDir = join(process.cwd(), "database", "migrations");
+  let files;
+  try {
+    files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql"));
+  } catch {
+    return;
+  }
+  const droppedMigrations = [], skipMigration = (file, reason) => {
+    log.info(`Skipping migration on SQLite (${reason}): ${file}`);
+    droppedMigrations.push(file);
+  }, deleteMigration = (file, filePath, reason) => {
+    log.info(`Dropping no-op migration (${reason}): ${file}`);
+    try {
+      unlinkSync(filePath);
+    } catch {}
+    droppedMigrations.push(file);
+  }, replayMigrations = [], addConstraintPattern = /^\s*ALTER\s+TABLE\s+.+\s+ADD\s+CONSTRAINT\s+/i, createTypePattern = /^\s*CREATE\s+TYPE\s+/i, createUniqueIndexPattern = /^\s*CREATE\s+UNIQUE\s+INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?["'`]?(\w+)["'`]?/i, dropColumnPattern = /^\s*ALTER\s+TABLE\s+["']?(\w+)["']?\s+DROP\s+COLUMN\s+["']?(\w+)["']?\s*$/i, createTablePattern = /^\s*CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?(\w+)["']?/i, createTableEarliest = new Map;
+  for (const file of files) {
+    const m = file.match(/^\d+-create-(\w+)-table\.sql$/);
+    if (!m || !m[1])
+      continue;
+    const tableName = m[1], existing = createTableEarliest.get(tableName);
+    if (!existing || file < existing)
+      createTableEarliest.set(tableName, file);
+  }
+  const sqliteDbPath = join(process.cwd(), dbConfig.connections.sqlite.database || "stacks.db");
+  let sqliteDb = null;
+  if (existsSync(sqliteDbPath))
+    try {
+      const { Database } = require("bun:sqlite");
+      sqliteDb = new Database(sqliteDbPath, { readonly: !0 });
+    } catch {}
+  for (const file of files) {
+    log.debug(`[migration] Running: ${file}`);
+    const filePath = join(migrationsDir, file), statements = readFileSync(filePath, "utf-8").split(";").map((s) => s.trim()).filter((s) => s.length > 0 && !s.startsWith("--"));
+    if (statements.length === 0)
+      continue;
+    const firstStatement = statements[0], createTableMatch = firstStatement ? firstStatement.match(createTablePattern) : null;
+    if (createTableMatch && createTableMatch[1]) {
+      const tableName = createTableMatch[1], earliest = createTableEarliest.get(tableName);
+      if (earliest && earliest !== file) {
+        deleteMigration(file, filePath, `duplicate create-table for "${tableName}" (kept ${earliest})`);
+        continue;
+      }
+    }
+    if (statements.every((s) => addConstraintPattern.test(s))) {
+      skipMigration(file, "SQLite does not support ALTER TABLE ADD CONSTRAINT");
+      continue;
+    }
+    if (statements.every((s) => createTypePattern.test(s))) {
+      skipMigration(file, "SQLite does not support CREATE TYPE (enum types)");
+      continue;
+    }
+    const uniqueIndexNames = statements.map((s) => s.match(createUniqueIndexPattern)?.[1]).filter((name) => Boolean(name));
+    if (sqliteDb && uniqueIndexNames.length === statements.length) {
+      const indexExists = sqliteDb.prepare("SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?");
+      if (uniqueIndexNames.filter((name) => !indexExists.get(name)).length > 0) {
+        log.info(`Re-queueing unique-index migration (index missing from database): ${file}`);
+        replayMigrations.push(file);
+      }
+      continue;
+    }
+    if (statements.some((s) => dropColumnPattern.test(s))) {
+      let modified = !1;
+      const filteredStatements = [];
+      for (const stmt of statements) {
+        const dropColMatch = stmt.match(dropColumnPattern);
+        if (dropColMatch && dropColMatch[1] && dropColMatch[2]) {
+          const tableName = dropColMatch[1], columnName = dropColMatch[2];
+          if (!sqliteDb) {
+            log.info(`Skipping DROP COLUMN "${columnName}" \u2014 no database exists yet: ${file}`);
+            modified = !0;
+            continue;
+          }
+          try {
+            const safeTableName = tableName.replace(/[^a-zA-Z0-9_]/g, ""), columns = sqliteDb.prepare(`PRAGMA table_info("${safeTableName}")`).all();
+            if (columns.length === 0) {
+              log.info(`Skipping DROP COLUMN "${columnName}" \u2014 table "${tableName}" does not exist yet: ${file}`);
+              modified = !0;
+              continue;
+            }
+            if (!columns.some((col) => col.name === columnName)) {
+              log.info(`Skipping DROP COLUMN "${columnName}" from "${tableName}" \u2014 column does not exist: ${file}`);
+              modified = !0;
+              continue;
+            }
+          } catch {
+            log.info(`Skipping DROP COLUMN "${columnName}" \u2014 table "${tableName}" not found: ${file}`);
+            modified = !0;
+            continue;
+          }
+        }
+        filteredStatements.push(stmt);
+      }
+      if (modified) {
+        if (filteredStatements.length === 0)
+          deleteMigration(file, filePath, "columns already absent from table");
+        else
+          writeFileSync(filePath, `${filteredStatements.join(`;
+`)};
+`);
+        continue;
+      }
+    }
+  }
+  if (sqliteDb)
+    try {
+      sqliteDb.close();
+    } catch {}
+  if (droppedMigrations.length > 0 || replayMigrations.length > 0)
+    try {
+      const dbPath = join(process.cwd(), dbConfig.connections.sqlite.database || "stacks.db");
+      mkdirSync(dirname(dbPath), { recursive: !0 });
+      const { Database } = require("bun:sqlite"), writeDb = new Database(dbPath);
+      try {
+        writeDb.exec(`CREATE TABLE IF NOT EXISTS migrations (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          migration TEXT NOT NULL UNIQUE,
+          executed_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )`);
+        const insert = writeDb.prepare("INSERT OR IGNORE INTO migrations (migration) VALUES (?)");
+        for (const migration of droppedMigrations)
+          insert.run(migration);
+        const unrecord = writeDb.prepare("DELETE FROM migrations WHERE migration = ?");
+        for (const migration of replayMigrations)
+          unrecord.run(migration);
+      } finally {
+        writeDb.close();
+      }
+    } catch (e) {
+      log.debug(`[migration] Could not record dropped migrations as executed: ${e}`);
+    }
+}
+async function ensureDatabaseExists() {
+  const dialect = getDialect();
+  if (dialect === "sqlite")
+    return;
+  const connectionConfig = dbConfig.connections[dialect], dbName = (connectionConfig?.name || "stacks").replace(/['"]/g, ""), host = connectionConfig?.host || "localhost", port = connectionConfig?.port || (dialect === "postgres" ? 5432 : 3306), username = connectionConfig?.username || (dialect === "postgres" ? process.env.USER || "postgres" : "root"), password = connectionConfig?.password || "", adminDatabase = dialect === "postgres" ? "postgres" : "mysql";
+  try {
+    setConfig({
+      dialect,
+      database: {
+        database: adminDatabase,
+        host,
+        port,
+        username,
+        password
+      }
+    });
+    resetConnection();
+    const adminDb = createQueryBuilder();
+    if (dialect === "postgres")
+      try {
+        await adminDb.unsafe(`CREATE DATABASE "${dbName}"`);
+        log.info(`Created database "${dbName}"`);
+      } catch (e) {
+        if (e?.message?.includes("already exists") || e?.errno === "42P04")
+          log.info(`Database "${dbName}" already exists`);
+        else
+          throw e;
+      }
+    else if (dialect === "mysql")
+      try {
+        await adminDb.unsafe(`CREATE DATABASE IF NOT EXISTS \`${dbName}\``);
+        log.info(`Ensured database "${dbName}" exists`);
+      } catch (e) {
+        if (e?.message?.includes("database exists"))
+          log.info(`Database "${dbName}" already exists`);
+        else
+          throw e;
+      }
+    resetConnection();
+  } catch (error) {
+    log.warn(`Could not auto-create database "${dbName}": ${error?.message || error}`);
+    log.info("If the database already exists, this warning can be ignored.");
+    resetConnection();
+  }
+}
+async function hideDisabledFeatureMigrations() {
+  const hidden = [];
+  try {
+    const { FEATURE_NAMES, migrationFeature } = await import("@stacksjs/buddy"), { feature: isFeatureEnabled } = await import("@stacksjs/config"), fs = await import("node:fs/promises"), migrationsDir = path.projectPath("database/migrations");
+    if (!existsSync(migrationsDir))
+      return hidden;
+    const disabledFeatures = new Set(FEATURE_NAMES.filter((f) => !isFeatureEnabled(f)));
+    if (disabledFeatures.size === 0)
+      return hidden;
+    const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql"));
+    for (const file of files) {
+      const owner = migrationFeature(file);
+      if (!owner || !disabledFeatures.has(owner))
+        continue;
+      const original = join(migrationsDir, file), hiddenPath = `${original}.disabled`;
+      await fs.rename(original, hiddenPath);
+      hidden.push({ original, hidden: hiddenPath, feature: owner });
+    }
+    if (hidden.length > 0) {
+      const summary = Object.entries(hidden.reduce((acc, h) => {
+        acc[h.feature] = (acc[h.feature] ?? 0) + 1;
+        return acc;
+      }, {})).map(([f, n]) => `${f}: ${n}`).join(", ");
+      log.info(`[migration] Skipping ${hidden.length} migration(s) for disabled features (${summary}). Run \`./buddy <feature>:install\` to enable.`);
+    }
+  } catch {}
+  return hidden;
+}
+async function restoreHiddenMigrations(hidden) {
+  const fs = await import("node:fs/promises");
+  for (const { original, hidden: h } of hidden)
+    try {
+      await fs.rename(h, original);
+    } catch {}
+}
+async function countAppliedMigrations() {
+  try {
+    const row = await db.selectFrom("migrations").select((eb) => eb.fn.count("id").as("n")).executeTakeFirst();
+    if (!row)
+      return 0;
+    const n = Number(row.n ?? row.N ?? 0);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+async function writeMigrateMarker(appliedCount) {
+  try {
+    const fs = await import("node:fs/promises"), dir = path.projectPath(".stacks");
+    await fs.mkdir(dir, { recursive: !0 });
+    const file = `${dir}/last-migrate-result.json`, body = JSON.stringify({
+      appliedCount,
+      completedAt: new Date().toISOString()
+    });
+    await fs.writeFile(file, body, "utf8");
+  } catch {}
+}
+export async function runDatabaseMigration() {
+  const startedAt = Date.now(), hidden = await hideDisabledFeatureMigrations();
+  let lockHandle = null;
+  try {
+    log.debug("Migrating database...");
+    await ensureDatabaseExists();
+    configureQueryBuilder();
+    const dialect = getDialect(), lockDb = dialect === "sqlite" ? null : createQueryBuilder();
+    lockHandle = await acquireMigrationLock(dialect, lockDb);
+    if (dialect === "sqlite")
+      preprocessSqliteMigrations();
+    const modelsDir = path.userModelsPath(), appliedBefore = await countAppliedMigrations();
+    log.debug(`[migration] Running migrations from: ${modelsDir}`);
+    await qbExecuteMigration(modelsDir);
+    const appliedAfter = await countAppliedMigrations(), appliedCount = Math.max(0, appliedAfter - appliedBefore);
+    await writeMigrateMarker(appliedCount);
+    log.debug(`Database migration completed in ${Date.now() - startedAt}ms (applied ${appliedCount}).`);
+    return ok(appliedCount === 0 ? "Nothing to migrate." : `Applied ${appliedCount} migration${appliedCount === 1 ? "" : "s"}.`);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    log.error(`[migration] Failed after ${Date.now() - startedAt}ms: ${detail}`);
+    log.info("[migration] Run `./buddy migrate:fresh` to drop and recreate the schema if state is partial.");
+    return err(handleError("Migration failed", error));
+  } finally {
+    if (lockHandle)
+      try {
+        await lockHandle.release();
+      } catch {}
+    await restoreHiddenMigrations(hidden);
+  }
+}
+const FRAMEWORK_TABLES = [
+  "oauth_refresh_tokens",
+  "oauth_access_tokens",
+  "oauth_clients",
+  "passkeys",
+  "failed_jobs",
+  "jobs",
+  "notifications",
+  "password_reset_tokens"
+];
+export async function resetDatabase() {
+  try {
+    configureQueryBuilder();
+    const modelsDir = path.userModelsPath(), dialect = getDialect();
+    await dropFrameworkTables(dialect);
+    await qbResetDatabase(modelsDir, { dialect });
+    return ok("All tables dropped successfully!");
+  } catch (error) {
+    return err(handleError("Database reset failed", error));
+  }
+}
+async function dropFrameworkTables(dialect) {
+  if (dialect === "mysql")
+    try {
+      await db.unsafe("SET FOREIGN_KEY_CHECKS = 0").execute();
+    } catch (error) {
+      log.warn(`Could not disable foreign key checks: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  if (dialect === "sqlite")
+    try {
+      await db.unsafe("PRAGMA foreign_keys = OFF").execute();
+    } catch (error) {
+      log.warn(`Could not disable foreign key checks: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  for (const tableName of FRAMEWORK_TABLES)
+    try {
+      let dropSql;
+      if (dialect === "postgres")
+        dropSql = `DROP TABLE IF EXISTS "${tableName}" CASCADE`;
+      else if (dialect === "mysql")
+        dropSql = `DROP TABLE IF EXISTS \`${tableName}\``;
+      else
+        dropSql = `DROP TABLE IF EXISTS "${tableName}"`;
+      log.info(`Dropping framework table: ${tableName}`);
+      await db.unsafe(dropSql).execute();
+      log.info(`Dropped framework table: ${tableName}`);
+    } catch (error) {
+      log.warn(`Could not drop table ${tableName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  if (dialect === "mysql")
+    try {
+      await db.unsafe("SET FOREIGN_KEY_CHECKS = 1").execute();
+    } catch (error) {
+      log.warn(`Could not re-enable foreign key checks: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  if (dialect === "sqlite")
+    try {
+      await db.unsafe("PRAGMA foreign_keys = ON").execute();
+    } catch (error) {
+      log.warn(`Could not re-enable foreign key checks: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function resolveGenerateOptions(options) {
+  const applyRenames = options.applyRenames ?? (process.env.STACKS_MIGRATE_NO_RENAME === "1" ? !1 : void 0), fromDb = options.fromDb ?? (process.env.STACKS_MIGRATE_FROM_DB === "1" ? !0 : void 0);
+  return { applyRenames, fromDb };
+}
+export async function previewPendingMigrations(options = {}) {
+  try {
+    configureQueryBuilder();
+    const dialect = getDialect(), { modelsDir, skip } = prepareMigrationModelsDir();
+    if (skip)
+      return [];
+    const { applyRenames, fromDb } = resolveGenerateOptions(options);
+    return (await qbGenerateMigration(modelsDir, { dialect: getQbDialect(), dryRun: !0, applyRenames, fromDb })).operations ?? [];
+  } catch (error) {
+    log.debug(`[migration] preview failed: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+export async function generateMigrations(options = {}) {
+  try {
+    log.debug("Generating migrations...");
+    configureQueryBuilder();
+    const dialect = getDialect(), { modelsDir, skip } = prepareMigrationModelsDir();
+    if (skip) {
+      log.debug("No app/Models directory found; using committed framework migrations");
+      return ok("Migrations generated");
+    }
+    const { applyRenames, fromDb } = resolveGenerateOptions(options);
+    log.debug(`[migration] Generating migrations for dialect: ${dialect}, models: ${modelsDir}`);
+    const result = await qbGenerateMigration(modelsDir, { dialect: getQbDialect(), dryRun: !0, applyRenames, fromDb });
+    if (result.hasChanges) {
+      const written = persistGeneratedMigrations(result.sqlStatements ?? []);
+      if (written > 0)
+        log.success(`Generated ${written} migration file${written === 1 ? "" : "s"}`);
+      else
+        log.debug("Migration generation produced no new files (already up to date)");
+    } else
+      log.debug("No changes detected");
+    return ok("Migrations generated");
+  } catch (error) {
+    return err(handleError("Migration generation failed", error));
+  }
+}
+function persistGeneratedMigrations(sqlStatements) {
+  if (!sqlStatements?.length)
+    return 0;
+  const migrationsDir = join(process.cwd(), "database", "migrations");
+  try {
+    require("node:fs").mkdirSync(migrationsDir, { recursive: !0 });
+  } catch {}
+  let existingSql = "";
+  try {
+    for (const f of readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")))
+      existingSql += `
+${readFileSync(join(migrationsDir, f), "utf8")}`;
+  } catch {}
+  const normalize = (s) => s.replace(/\s+/g, " ").trim(), haystack = normalize(existingSql), groups = groupGeneratedStatements(sqlStatements);
+  let written = 0, cursor = nextMigrationNumber(migrationsDir);
+  for (const group of groups) {
+    const fresh = group.statements.filter((stmt) => !haystack.includes(normalize(stmt)));
+    if (fresh.length === 0)
+      continue;
+    const filename = `${String(cursor).padStart(10, "0")}-${group.label}.sql`, filePath = join(migrationsDir, filename), body = `${fresh.map((s) => s.trim().replace(/;\s*$/, "")).join(`;
+`)};
+`;
+    writeFileSync(filePath, body);
+    log.debug(`[migration] Wrote ${filename} (${fresh.length} stmt${fresh.length === 1 ? "" : "s"})`);
+    written += 1;
+    cursor += 1;
+  }
+  return written;
+}
+function groupGeneratedStatements(sqlStatements) {
+  const groups = new Map, push = (label, stmt) => {
+    const list = groups.get(label) ?? [];
+    list.push(stmt);
+    groups.set(label, list);
+  };
+  for (const raw of sqlStatements) {
+    const stmt = raw.trim();
+    if (!stmt)
+      continue;
+    const create = stmt.match(/^\s*CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?(\w+)["`]?/i);
+    if (create) {
+      push(`create-${create[1]}-table`, stmt);
+      continue;
+    }
+    const alter = stmt.match(/^\s*ALTER\s+TABLE\s+["`]?(\w+)["`]?\s+(?:ADD\s+COLUMN\s+["`]?(\w+)["`]?|DROP\s+COLUMN\s+["`]?(\w+)["`]?|ADD\s+CONSTRAINT)/i);
+    if (alter) {
+      push(`alter-${alter[1]}-${alter[2] || alter[3] || "constraint"}`, stmt);
+      continue;
+    }
+    const idx = stmt.match(/^\s*CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?(\w+)["`]?\s+ON\s+["`]?(\w+)["`]?/i);
+    if (idx) {
+      push(`create-${idx[1]}-index-in-${idx[2]}`, stmt);
+      continue;
+    }
+    const drop = stmt.match(/^\s*DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?["`]?(\w+)["`]?/i);
+    if (drop) {
+      push(`drop-${drop[1]}-table`, stmt);
+      continue;
+    }
+    push("auto-misc", stmt);
+  }
+  return [...groups.entries()].map(([label, statements]) => ({ label, statements }));
+}
+function nextMigrationNumber(migrationsDir) {
+  let max = 0;
+  try {
+    for (const f of readdirSync(migrationsDir)) {
+      const m = f.match(/^(\d+)-/);
+      if (m?.[1])
+        max = Math.max(max, Number.parseInt(m[1], 10));
+    }
+  } catch {}
+  return max + 1;
+}
+export async function generateMigrations2() {
+  try {
+    log.info("Generating fresh migrations...");
+    configureQueryBuilder();
+    const dialect = getDialect(), { modelsDir, skip } = prepareMigrationModelsDir();
+    if (skip) {
+      log.info("No app/Models directory found; using committed framework migrations");
+      return ok("Migrations generated");
+    }
+    await qbGenerateMigration(modelsDir, { dialect: getQbDialect(), full: !0, dryRun: !0 });
+    log.success("Migrations generated");
+    return ok("Migrations generated");
+  } catch (error) {
+    return err(handleError("Fresh migration generation failed", error));
+  }
+}