migraguard 0.7.0 → 0.8.0

package/dist/cli.js

@@ -1,10 +1,10 @@
-import { execFile } from 'child_process';
+import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
+import { readFile, mkdir, writeFile, rm, unlink, readdir, stat, copyFile } from 'fs/promises';
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { createRequire } from 'module';
 import pg from 'pg';
-import { readFile, mkdir, writeFile, rm, unlink, readdir, stat } from 'fs/promises';
 import { dirname, resolve, join } from 'path';
 import { existsSync } from 'fs';
 import { randomBytes, createHash } from 'crypto';
@@ -23,13 +23,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-
-// src/psql.ts
-var psql_exports = {};
-__export(psql_exports, {
-  executePsqlFile: () => executePsqlFile,
-  isPsqlAvailable: () => isPsqlAvailable
-});
 function buildPsqlEnv(config) {
   const env = { ...process.env };
   env["PGHOST"] = config.connection.host;
@@ -59,23 +52,300 @@ async function executePsqlFile(config, filePath) {
     };
   }
 }
-async function isPsqlAvailable() {
-  try {
-    await execFileAsync("psql", ["--version"]);
-    return true;
-  } catch {
-    return false;
-  }
-}
 var execFileAsync;
 var init_psql = __esm({
   "src/psql.ts"() {
     execFileAsync = promisify(execFile);
   }
 });
-var { Client } = pg;
+
+// src/executor.ts
+var executor_exports = {};
+__export(executor_exports, {
+  executeSqlFile: () => executeSqlFile,
+  spawnWithStdin: () => spawnWithStdin
+});
+async function executeSqlFile(config, filePath) {
+  switch (config.dialect) {
+    case "mysql":
+      return executeMysqlFile(config, filePath);
+    case "sqlite":
+      return executeSqliteFile(config, filePath);
+    default:
+      return executePsqlFile(config, filePath);
+  }
+}
+async function executeMysqlFile(config, filePath) {
+  const args = [
+    `--host=${config.connection.host}`,
+    `--port=${config.connection.port}`,
+    `--user=${config.connection.user}`,
+    `--database=${config.connection.database}`,
+    "--batch"
+  ];
+  const env = { ...process.env };
+  if (config.connection.password) {
+    env["MYSQL_PWD"] = config.connection.password;
+  }
+  const sql = await readFile(filePath, "utf-8");
+  return spawnWithStdin("mysql", args, sql, env);
+}
+async function executeSqliteFile(config, filePath) {
+  const sql = await readFile(filePath, "utf-8");
+  return spawnWithStdin("sqlite3", ["-bail", config.connection.database], sql);
+}
+function spawnWithStdin(cmd, args, input, env) {
+  return new Promise((resolve4) => {
+    const proc = spawn(cmd, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: env ?? process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("error", (err) => {
+      resolve4({ success: false, stdout, stderr: err.message });
+    });
+    proc.on("close", (code) => {
+      resolve4({ success: code === 0, stdout, stderr });
+    });
+    proc.stdin.write(input);
+    proc.stdin.end();
+  });
+}
+var init_executor = __esm({
+  "src/executor.ts"() {
+    init_psql();
+  }
+});
+
+// src/db-mysql.ts
 var ADVISORY_LOCK_KEY = "migraguard-apply";
 var CREATE_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS schema_migrations (
+    id              BIGINT       AUTO_INCREMENT PRIMARY KEY,
+    file_name       VARCHAR(256) NOT NULL,
+    checksum        VARCHAR(64)  NOT NULL,
+    status          VARCHAR(16)  NOT NULL DEFAULT 'applied',
+    applied_at      TIMESTAMP(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
+    resolved_at     TIMESTAMP(6) NULL,
+    migration_class VARCHAR(16)  DEFAULT 'safe',
+    phase           VARCHAR(16)  NULL,
+    group_name      VARCHAR(256) NULL
+) ENGINE=InnoDB;
+`;
+var MigraguardDbMysql = class {
+  config;
+  connection = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    let mysql;
+    try {
+      const id = "mysql2/promise";
+      const mod = await import(
+        /* @vite-ignore */
+        id
+      );
+      mysql = mod.default;
+    } catch {
+      throw new Error(
+        "mysql2 is required for MySQL dialect. Install it: npm install mysql2"
+      );
+    }
+    this.connection = await mysql.createConnection({
+      host: this.config.connection.host,
+      port: this.config.connection.port,
+      database: this.config.connection.database,
+      user: this.config.connection.user,
+      password: this.config.connection.password
+    });
+  }
+  async close() {
+    await this.connection?.end();
+  }
+  async ensureTable() {
+    await this.exec(CREATE_TABLE_SQL);
+  }
+  async acquireAdvisoryLock() {
+    await this.exec(`SELECT GET_LOCK(?, -1)`, [ADVISORY_LOCK_KEY]);
+  }
+  async releaseAdvisoryLock() {
+    await this.exec(`SELECT RELEASE_LOCK(?)`, [ADVISORY_LOCK_KEY]);
+  }
+  async getAllRecords() {
+    const rows = await this.queryRows(
+      `SELECT file_name, checksum, status, applied_at, resolved_at,
+              migration_class, phase, group_name
+       FROM schema_migrations
+       ORDER BY applied_at ASC`
+    );
+    return rows.map(mapRow);
+  }
+  async getRecordsForFile(fileName) {
+    const rows = await this.queryRows(
+      `SELECT file_name, checksum, status, applied_at, resolved_at,
+              migration_class, phase, group_name
+       FROM schema_migrations
+       WHERE file_name = ?
+       ORDER BY applied_at ASC`,
+      [fileName]
+    );
+    return rows.map(mapRow);
+  }
+  async insertRecord(fileName, checksum, status, options) {
+    const migrationClass = options?.migrationClass ?? "safe";
+    const phase = options?.phase ?? null;
+    const groupName = options?.groupName ?? null;
+    if (status === "skipped") {
+      await this.exec(
+        `INSERT INTO schema_migrations (file_name, checksum, status, resolved_at, migration_class, phase, group_name)
+         VALUES (?, ?, ?, CURRENT_TIMESTAMP(6), ?, ?, ?)`,
+        [fileName, checksum, status, migrationClass, phase, groupName]
+      );
+    } else {
+      await this.exec(
+        `INSERT INTO schema_migrations (file_name, checksum, status, migration_class, phase, group_name)
+         VALUES (?, ?, ?, ?, ?, ?)`,
+        [fileName, checksum, status, migrationClass, phase, groupName]
+      );
+    }
+  }
+  conn() {
+    if (!this.connection) throw new Error("Not connected");
+    return this.connection;
+  }
+  async exec(sql, values) {
+    await this.conn().execute(sql, values);
+  }
+  async queryRows(sql, values) {
+    const [rows] = await this.conn().execute(sql, values);
+    return rows;
+  }
+};
+function mapRow(row) {
+  return {
+    fileName: row["file_name"],
+    checksum: row["checksum"],
+    status: row["status"],
+    appliedAt: row["applied_at"] instanceof Date ? row["applied_at"] : new Date(row["applied_at"]),
+    resolvedAt: row["resolved_at"] ? row["resolved_at"] instanceof Date ? row["resolved_at"] : new Date(row["resolved_at"]) : null,
+    migrationClass: row["migration_class"] ?? "safe",
+    phase: row["phase"] ?? null,
+    groupName: row["group_name"] ?? null
+  };
+}
+
+// src/db-sqlite.ts
+var CREATE_TABLE_SQL2 = `
+CREATE TABLE IF NOT EXISTS schema_migrations (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_name       TEXT    NOT NULL,
+    checksum        TEXT    NOT NULL,
+    status          TEXT    NOT NULL DEFAULT 'applied',
+    applied_at      TEXT    NOT NULL DEFAULT (datetime('now')),
+    resolved_at     TEXT,
+    migration_class TEXT    DEFAULT 'safe',
+    phase           TEXT,
+    group_name      TEXT
+);
+`;
+var MigraguardDbSqlite = class {
+  config;
+  database = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    let Database;
+    try {
+      const id = "better-sqlite3";
+      const mod = await import(
+        /* @vite-ignore */
+        id
+      );
+      Database = mod.default;
+    } catch {
+      throw new Error(
+        "better-sqlite3 is required for SQLite dialect. Install it: npm install better-sqlite3"
+      );
+    }
+    this.database = new Database(this.config.connection.database);
+    this.db().pragma("journal_mode = WAL");
+  }
+  async close() {
+    this.database?.close();
+  }
+  async ensureTable() {
+    this.db().exec(CREATE_TABLE_SQL2);
+  }
+  async acquireAdvisoryLock() {
+  }
+  async releaseAdvisoryLock() {
+  }
+  async getAllRecords() {
+    const rows = this.db().prepare(
+      `SELECT file_name, checksum, status, applied_at, resolved_at,
+              migration_class, phase, group_name
+       FROM schema_migrations
+       ORDER BY applied_at ASC`
+    ).all();
+    return rows.map(mapRow2);
+  }
+  async getRecordsForFile(fileName) {
+    const rows = this.db().prepare(
+      `SELECT file_name, checksum, status, applied_at, resolved_at,
+              migration_class, phase, group_name
+       FROM schema_migrations
+       WHERE file_name = ?
+       ORDER BY applied_at ASC`
+    ).all(fileName);
+    return rows.map(mapRow2);
+  }
+  async insertRecord(fileName, checksum, status, options) {
+    const migrationClass = options?.migrationClass ?? "safe";
+    const phase = options?.phase ?? null;
+    const groupName = options?.groupName ?? null;
+    if (status === "skipped") {
+      this.db().prepare(
+        `INSERT INTO schema_migrations (file_name, checksum, status, resolved_at, migration_class, phase, group_name)
+         VALUES (?, ?, ?, datetime('now'), ?, ?, ?)`
+      ).run(fileName, checksum, status, migrationClass, phase, groupName);
+    } else {
+      this.db().prepare(
+        `INSERT INTO schema_migrations (file_name, checksum, status, migration_class, phase, group_name)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(fileName, checksum, status, migrationClass, phase, groupName);
+    }
+  }
+  db() {
+    if (!this.database) throw new Error("Not connected");
+    return this.database;
+  }
+};
+function mapRow2(row) {
+  return {
+    fileName: row["file_name"],
+    checksum: row["checksum"],
+    status: row["status"],
+    appliedAt: new Date(row["applied_at"]),
+    resolvedAt: row["resolved_at"] ? new Date(row["resolved_at"]) : null,
+    migrationClass: row["migration_class"] ?? "safe",
+    phase: row["phase"] ?? null,
+    groupName: row["group_name"] ?? null
+  };
+}
+
+// src/db.ts
+var { Client } = pg;
+var ADVISORY_LOCK_KEY2 = "migraguard-apply";
+var CREATE_TABLE_SQL3 = `
 CREATE TABLE IF NOT EXISTS schema_migrations (
     id          BIGSERIAL    PRIMARY KEY,
     file_name   VARCHAR(256) NOT NULL,
@@ -91,6 +361,16 @@ ALTER TABLE schema_migrations
   ADD COLUMN IF NOT EXISTS phase VARCHAR(16),
   ADD COLUMN IF NOT EXISTS group_name VARCHAR(256);
 `;
+function createDb(config) {
+  switch (config.dialect) {
+    case "mysql":
+      return new MigraguardDbMysql(config);
+    case "sqlite":
+      return new MigraguardDbSqlite(config);
+    default:
+      return new MigraguardDb(config);
+  }
+}
 var MigraguardDb = class {
   client;
   constructor(config) {
@@ -109,14 +389,14 @@ var MigraguardDb = class {
     await this.client.end();
   }
   async ensureTable() {
-    await this.client.query(CREATE_TABLE_SQL);
+    await this.client.query(CREATE_TABLE_SQL3);
     await this.client.query(ALTER_TABLE_SQL);
   }
   async acquireAdvisoryLock() {
-    await this.client.query(`SELECT pg_advisory_lock(hashtext($1))`, [ADVISORY_LOCK_KEY]);
+    await this.client.query(`SELECT pg_advisory_lock(hashtext($1))`, [ADVISORY_LOCK_KEY2]);
   }
   async releaseAdvisoryLock() {
-    await this.client.query(`SELECT pg_advisory_unlock(hashtext($1))`, [ADVISORY_LOCK_KEY]);
+    await this.client.query(`SELECT pg_advisory_unlock(hashtext($1))`, [ADVISORY_LOCK_KEY2]);
   }
   async getAllRecords() {
     const result = await this.client.query(
@@ -125,7 +405,7 @@ var MigraguardDb = class {
        FROM schema_migrations
        ORDER BY applied_at ASC`
     );
-    return result.rows.map(mapRow);
+    return result.rows.map(mapRow3);
   }
   async getRecordsForFile(fileName) {
     const result = await this.client.query(
@@ -136,7 +416,7 @@ var MigraguardDb = class {
        ORDER BY applied_at ASC`,
       [fileName]
     );
-    return result.rows.map(mapRow);
+    return result.rows.map(mapRow3);
   }
   async insertRecord(fileName, checksum, status, options) {
     const migrationClass = options?.migrationClass ?? "safe";
@@ -160,7 +440,7 @@ var MigraguardDb = class {
     return this.client;
   }
 };
-function mapRow(row) {
+function mapRow3(row) {
   return {
     fileName: row["file_name"],
     checksum: row["checksum"],
@@ -172,6 +452,9 @@ function mapRow(row) {
     groupName: row["group_name"] ?? null
   };
 }
+
+// src/index.ts
+init_executor();
 var CONFIG_FILE_NAME = "migraguard.config.json";
 var DEFAULT_NAMING = {
   pattern: "{timestamp}__{description}.sql",
@@ -179,12 +462,16 @@ var DEFAULT_NAMING = {
   prefix: "",
   sortKey: "timestamp"
 };
-var DEFAULT_CONNECTION = {
-  host: "localhost",
-  port: 5432,
-  database: "postgres",
-  user: "postgres"
-};
+function getDefaultConnection(dialect) {
+  switch (dialect) {
+    case "mysql":
+      return { host: "localhost", port: 3306, database: "mysql", user: "root" };
+    case "sqlite":
+      return { host: "", port: 0, database: "./database.sqlite3", user: "" };
+    default:
+      return { host: "localhost", port: 5432, database: "postgres", user: "postgres" };
+  }
+}
 var DEFAULT_DUMP = {
   normalize: true,
   excludeOwners: true,
@@ -251,14 +538,30 @@ function getDefaultLintRules(dialect) {
 var DEFAULT_LINT = {
   rules: DEFAULT_PG_LINT_RULES
 };
-function applyEnvOverrides(connection) {
-  return {
-    host: process.env["PGHOST"] ?? connection.host,
-    port: process.env["PGPORT"] ? parseInt(process.env["PGPORT"], 10) : connection.port,
-    database: process.env["PGDATABASE"] ?? connection.database,
-    user: process.env["PGUSER"] ?? connection.user,
-    password: process.env["PGPASSWORD"] ?? connection.password
-  };
+function applyEnvOverrides(connection, dialect) {
+  switch (dialect) {
+    case "mysql":
+      return {
+        host: process.env["MYSQL_HOST"] ?? connection.host,
+        port: process.env["MYSQL_TCP_PORT"] ? parseInt(process.env["MYSQL_TCP_PORT"], 10) : connection.port,
+        database: process.env["MYSQL_DATABASE"] ?? connection.database,
+        user: process.env["MYSQL_USER"] ?? connection.user,
+        password: process.env["MYSQL_PWD"] ?? connection.password
+      };
+    case "sqlite":
+      return {
+        ...connection,
+        database: process.env["SQLITE_DATABASE"] ?? connection.database
+      };
+    default:
+      return {
+        host: process.env["PGHOST"] ?? connection.host,
+        port: process.env["PGPORT"] ? parseInt(process.env["PGPORT"], 10) : connection.port,
+        database: process.env["PGDATABASE"] ?? connection.database,
+        user: process.env["PGUSER"] ?? connection.user,
+        password: process.env["PGPASSWORD"] ?? connection.password
+      };
+  }
 }
 function resolveMigrationsDirs(raw) {
   if (raw.migrationsDirs && raw.migrationsDirs.length > 0) {
@@ -287,7 +590,7 @@ function findConfigFile(startDir) {
 function buildConfig(raw, configDir) {
   const dialect = raw.dialect ?? "postgresql";
   const connection = {
-    ...DEFAULT_CONNECTION,
+    ...getDefaultConnection(dialect),
     ...raw.connection
   };
   const defaultRules = getDefaultLintRules(dialect);
@@ -299,7 +602,7 @@ function buildConfig(raw, configDir) {
     schemaFile: raw.schemaFile ?? "db/schema.sql",
     metadataFile: raw.metadataFile ?? "db/.migraguard/metadata.json",
     naming: { ...DEFAULT_NAMING, ...raw.naming },
-    connection: applyEnvOverrides(connection),
+    connection: applyEnvOverrides(connection, dialect),
     dump: { ...DEFAULT_DUMP, ...raw.dump },
     lint: {
       ...DEFAULT_LINT,
@@ -663,7 +966,7 @@ async function checksumFile(filePath) {
 }
 
 // src/commands/apply.ts
-init_psql();
+init_executor();
 var execFileAsync2 = promisify(execFile);
 function buildPgDumpEnv(config) {
   const env = { ...process.env };
@@ -677,6 +980,16 @@ function buildPgDumpEnv(config) {
   return env;
 }
 async function dumpSchema(config) {
+  switch (config.dialect) {
+    case "mysql":
+      return dumpMysqlSchema(config);
+    case "sqlite":
+      return dumpSqliteSchema(config);
+    default:
+      return dumpPgSchema(config);
+  }
+}
+async function dumpPgSchema(config) {
   const pgDumpCmd = config.dump.pgDumpCommand;
   const dumpArgs = ["--schema-only"];
   if (config.dump.excludeOwners) dumpArgs.push("--no-owner");
@@ -696,6 +1009,35 @@ async function dumpSchema(config) {
   }
   return stdout;
 }
+async function dumpMysqlSchema(config) {
+  const args = [
+    "--no-data",
+    "--skip-comments",
+    `--host=${config.connection.host}`,
+    `--port=${config.connection.port}`,
+    `--user=${config.connection.user}`,
+    config.connection.database
+  ];
+  const env = { ...process.env };
+  if (config.connection.password) {
+    env["MYSQL_PWD"] = config.connection.password;
+  }
+  const { stdout } = await execFileAsync2("mysqldump", args, { env });
+  if (config.dump.normalize) {
+    return normalizeMysqlSchema(stdout);
+  }
+  return stdout;
+}
+async function dumpSqliteSchema(config) {
+  const { stdout } = await execFileAsync2("sqlite3", [
+    config.connection.database,
+    ".schema"
+  ]);
+  if (config.dump.normalize) {
+    return normalizeSqliteSchema(stdout);
+  }
+  return stdout;
+}
 function normalizeSchema(raw) {
   const lines = raw.split("\n");
   const filtered = lines.filter((line) => {
@@ -707,9 +1049,30 @@ function normalizeSchema(raw) {
     if (line.startsWith("\\unrestrict")) return false;
     return true;
   });
+  return collapseAndTrim(filtered);
+}
+function normalizeMysqlSchema(raw) {
+  const lines = raw.split("\n");
+  const filtered = lines.filter((line) => {
+    if (line.startsWith("--")) return false;
+    if (line.startsWith("/*")) return false;
+    if (line.startsWith("/*!")) return false;
+    if (line.startsWith("SET ")) return false;
+    if (line.startsWith("LOCK TABLES")) return false;
+    if (line.startsWith("UNLOCK TABLES")) return false;
+    return true;
+  });
+  return collapseAndTrim(filtered);
+}
+function normalizeSqliteSchema(raw) {
+  const lines = raw.split("\n");
+  const filtered = lines.filter((line) => !line.startsWith("--"));
+  return collapseAndTrim(filtered);
+}
+function collapseAndTrim(lines) {
   const result = [];
   let prevBlank = false;
-  for (const line of filtered) {
+  for (const line of lines) {
     const isBlank = line.trim() === "";
     if (isBlank && prevBlank) continue;
     result.push(line);
@@ -1417,7 +1780,7 @@ async function commandApply(config, options) {
     graph = await buildDependencyGraph(config);
     leafSet = new Set(findLeafNodes(graph));
   }
-  const db = new MigraguardDb(config);
+  const db = createDb(config);
   try {
     await db.connect();
     await db.ensureTable();
@@ -1540,7 +1903,7 @@ async function commandApply(config, options) {
 }
 async function processFile(config, db, filePath, fileName, fileRecords, latestRecord, currentChecksum, isEditable, result, insertOpts) {
   if (!latestRecord) {
-    const psqlResult = await executePsqlFile(config, filePath);
+    const psqlResult = await executeSqlFile(config, filePath);
     if (psqlResult.success) {
       await db.insertRecord(fileName, currentChecksum, "applied", insertOpts);
       result.applied.push(fileName);
@@ -1563,7 +1926,7 @@ async function processFile(config, db, filePath, fileName, fileRecords, latestRe
   if (latestRecord.status === "failed") {
     if (isEditable) {
       console.log(chalk.yellow(`  \u21BB retrying failed: ${fileName}`));
-      const psqlResult = await executePsqlFile(config, filePath);
+      const psqlResult = await executeSqlFile(config, filePath);
       if (psqlResult.success) {
         await db.insertRecord(fileName, currentChecksum, "applied", insertOpts);
         result.applied.push(fileName);
@@ -1600,7 +1963,7 @@ async function processFile(config, db, filePath, fileName, fileRecords, latestRe
   }
   if (isEditable) {
     console.log(chalk.yellow(`  \u21BB re-applying (changed): ${fileName}`));
-    const psqlResult = await executePsqlFile(config, filePath);
+    const psqlResult = await executeSqlFile(config, filePath);
     if (psqlResult.success) {
       await db.insertRecord(fileName, currentChecksum, "applied", insertOpts);
       result.applied.push(fileName);
@@ -1629,8 +1992,8 @@ async function applyFromBaseline(config, db, metadata, result) {
     return;
   }
   console.log(chalk.blue("Applying baseline schema..."));
-  const { executePsqlFile: execPsql } = await Promise.resolve().then(() => (init_psql(), psql_exports));
-  const psqlResult = await execPsql(config, schemaPath);
+  const { executeSqlFile: execSql } = await Promise.resolve().then(() => (init_executor(), executor_exports));
+  const psqlResult = await execSql(config, schemaPath);
   if (!psqlResult.success) {
     result.errors.push(`Failed to apply baseline schema: ${psqlResult.stderr}`);
     console.error(chalk.red(`  \u2717 baseline schema apply failed`));
@@ -1648,7 +2011,7 @@ async function applyFromBaseline(config, db, metadata, result) {
   }
 }
 async function commandGroupStatus(config, groupName) {
-  const db = new MigraguardDb(config);
+  const db = createDb(config);
   try {
     await db.connect();
     await db.ensureTable();
@@ -1708,7 +2071,7 @@ var STATUS_MAP = {
 };
 async function commandAdvance(config, options) {
   const { group, phase, status } = options;
-  const db = new MigraguardDb(config);
+  const db = createDb(config);
   try {
     await db.connect();
     await db.ensureTable();
@@ -1759,7 +2122,7 @@ async function commandGate(config, options) {
       forbidden: options.forbidden ?? []
     };
   }
-  const db = new MigraguardDb(config);
+  const db = createDb(config);
   try {
     await db.connect();
     await db.ensureTable();
@@ -1822,10 +2185,10 @@ function matchesState(currentState, targetState) {
   if (currentIdx === -1 || targetIdx === -1) return false;
   return currentIdx >= targetIdx;
 }
-init_psql();
+init_executor();
 async function commandApplyPhase(config, options) {
   const { group, phase } = options;
-  const db = new MigraguardDb(config);
+  const db = createDb(config);
   try {
     await db.connect();
     await db.ensureTable();
@@ -1847,7 +2210,7 @@ async function commandApplyPhase(config, options) {
       return { success: false, group, phase, error: msg };
     }
     const checksum = await checksumFile(file.filePath);
-    const psqlResult = await executePsqlFile(config, file.filePath);
+    const psqlResult = await executeSqlFile(config, file.filePath);
     if (psqlResult.success) {
       await db.insertRecord(file.fileName, checksum, "applied", {
         migrationClass: "expand_contract",
@@ -1873,7 +2236,7 @@ async function commandApplyPhase(config, options) {
   }
 }
 async function commandBaseline(config, options) {
-  const db = new MigraguardDb(config);
+  const db = createDb(config);
   try {
     await db.connect();
     await db.ensureTable();
@@ -4218,7 +4581,7 @@ async function commandEditable(config) {
   }
   let dbConnected = false;
   try {
-    const db = new MigraguardDb(config);
+    const db = createDb(config);
     await db.connect();
     dbConnected = true;
     try {
@@ -4270,7 +4633,7 @@ function getLatestRecord3(records) {
   );
 }
 async function commandStatus(config) {
-  const db = new MigraguardDb(config);
+  const db = createDb(config);
   const entries = [];
   let groups = [];
   try {
@@ -4395,7 +4758,7 @@ function formatGroupState(state) {
   }
 }
 async function commandResolve(config, fileName) {
-  const db = new MigraguardDb(config);
+  const db = createDb(config);
   try {
     await db.connect();
     await db.ensureTable();
@@ -4464,14 +4827,13 @@ async function commandDiff(config) {
   console.error(diff);
   return { identical: false, diff };
 }
-init_psql();
+init_executor();
 var { Client: Client2 } = pg;
 var execFileAsync3 = promisify(execFile);
-function shadowDbName() {
-  const suffix = randomBytes(4).toString("hex");
-  return `migraguard_shadow_${suffix}`;
+function shadowId() {
+  return randomBytes(4).toString("hex");
 }
-function buildEnv(conn) {
+function buildPgEnv(conn) {
   const env = { ...process.env };
   env["PGHOST"] = conn.host;
   env["PGPORT"] = String(conn.port);
@@ -4479,7 +4841,7 @@ function buildEnv(conn) {
   if (conn.password) env["PGPASSWORD"] = conn.password;
   return env;
 }
-async function createShadowDb(conn, dbName) {
+async function createPgShadow(conn, dbName) {
   const client = new Client2({
     host: conn.host,
     port: conn.port,
@@ -4494,7 +4856,7 @@ async function createShadowDb(conn, dbName) {
     await client.end();
   }
 }
-async function dropShadowDb(conn, dbName) {
+async function dropPgShadow(conn, dbName) {
   const client = new Client2({
     host: conn.host,
     port: conn.port,
@@ -4509,9 +4871,9 @@ async function dropShadowDb(conn, dbName) {
     await client.end();
   }
 }
-async function dumpSourceToShadow(config, shadowName) {
+async function dumpPgSourceToShadow(config, shadowName2) {
   const conn = config.connection;
-  const env = buildEnv(conn);
+  const env = buildPgEnv(conn);
   const pgDumpCmd = config.dump.pgDumpCommand;
   let dumpOutput;
   if (pgDumpCmd && pgDumpCmd.length > 0) {
@@ -4526,8 +4888,8 @@ async function dumpSourceToShadow(config, shadowName) {
   const tmpFile = join(tmpdir(), `migraguard-dump-${randomBytes(4).toString("hex")}.sql`);
   await writeFile(tmpFile, dumpOutput, "utf-8");
   try {
-    const restoreEnv = buildEnv(conn);
-    restoreEnv["PGDATABASE"] = shadowName;
+    const restoreEnv = buildPgEnv(conn);
+    restoreEnv["PGDATABASE"] = shadowName2;
     await execFileAsync3("psql", ["-v", "ON_ERROR_STOP=1", "-f", tmpFile], {
       env: restoreEnv,
       maxBuffer: 50 * 1024 * 1024
@@ -4537,117 +4899,182 @@ async function dumpSourceToShadow(config, shadowName) {
     });
   }
 }
-function shadowConfig(config, shadowName) {
+async function createMysqlShadow(config, dbName) {
+  const args = [
+    `--host=${config.connection.host}`,
+    `--port=${config.connection.port}`,
+    `--user=${config.connection.user}`
+  ];
+  const env = { ...process.env };
+  if (config.connection.password) env["MYSQL_PWD"] = config.connection.password;
+  const safeName = dbName.replace(/`/g, "``");
+  await spawnWithStdin("mysql", args, `CREATE DATABASE \`${safeName}\`;`, env);
+}
+async function dropMysqlShadow(config, dbName) {
+  const args = [
+    `--host=${config.connection.host}`,
+    `--port=${config.connection.port}`,
+    `--user=${config.connection.user}`
+  ];
+  const env = { ...process.env };
+  if (config.connection.password) env["MYSQL_PWD"] = config.connection.password;
+  const safeName = dbName.replace(/`/g, "``");
+  await spawnWithStdin("mysql", args, `DROP DATABASE IF EXISTS \`${safeName}\`;`, env);
+}
+async function dumpMysqlSourceToShadow(config, shadowName2) {
+  const conn = config.connection;
+  const env = { ...process.env };
+  if (conn.password) env["MYSQL_PWD"] = conn.password;
+  const { stdout: dumpOutput } = await execFileAsync3("mysqldump", [
+    `--host=${conn.host}`,
+    `--port=${conn.port}`,
+    `--user=${conn.user}`,
+    conn.database
+  ], { env });
+  const restoreArgs = [
+    `--host=${conn.host}`,
+    `--port=${conn.port}`,
+    `--user=${conn.user}`,
+    `--database=${shadowName2}`
+  ];
+  await spawnWithStdin("mysql", restoreArgs, dumpOutput, env);
+}
+async function dumpSqliteSourceToShadow(config, shadowPath) {
+  await copyFile(config.connection.database, shadowPath);
+}
+async function dropSqliteShadow(shadowPath) {
+  await unlink(shadowPath).catch(() => {
+  });
+  await unlink(shadowPath + "-wal").catch(() => {
+  });
+  await unlink(shadowPath + "-shm").catch(() => {
+  });
+}
+function shadowName(config, id) {
+  if (config.dialect === "sqlite") {
+    return join(tmpdir(), `migraguard_shadow_${id}.sqlite3`);
+  }
+  return `migraguard_shadow_${id}`;
+}
+async function createShadow(config, name) {
+  switch (config.dialect) {
+    case "mysql":
+      return createMysqlShadow(config, name);
+    case "sqlite":
+      return;
+    // created on first access
+    default:
+      return createPgShadow(config.connection, name);
+  }
+}
+async function dropShadow(config, name) {
+  switch (config.dialect) {
+    case "mysql":
+      return dropMysqlShadow(config, name);
+    case "sqlite":
+      return dropSqliteShadow(name);
+    default:
+      return dropPgShadow(config.connection, name);
+  }
+}
+async function cloneSourceToShadow(config, name) {
+  switch (config.dialect) {
+    case "mysql":
+      return dumpMysqlSourceToShadow(config, name);
+    case "sqlite":
+      return dumpSqliteSourceToShadow(config, name);
+    default:
+      return dumpPgSourceToShadow(config, name);
+  }
+}
+function buildShadowConfig(config, name) {
   return {
     ...config,
-    connection: { ...config.connection, database: shadowName },
-    dump: {
-      ...config.dump,
-      pgDumpCommand: void 0
-    }
+    connection: { ...config.connection, database: name },
+    dump: { ...config.dump, pgDumpCommand: void 0 }
   };
 }
-function shadowDumpConfig(config, shadowName) {
+function buildShadowDumpConfig(config, name) {
+  if (config.dialect !== "postgresql") {
+    return buildShadowConfig(config, name);
+  }
   const basePgDumpCmd = config.dump.pgDumpCommand;
   let pgDumpCommand;
   if (basePgDumpCmd && basePgDumpCmd.length > 0) {
     pgDumpCommand = [...basePgDumpCmd];
     const dbFlagIdx = pgDumpCommand.indexOf("-d");
     if (dbFlagIdx >= 0 && dbFlagIdx + 1 < pgDumpCommand.length) {
-      pgDumpCommand[dbFlagIdx + 1] = shadowName;
+      pgDumpCommand[dbFlagIdx + 1] = name;
     } else {
-      pgDumpCommand.push("-d", shadowName);
+      pgDumpCommand.push("-d", name);
     }
   }
   return {
     ...config,
-    connection: { ...config.connection, database: shadowName },
+    connection: { ...config.connection, database: name },
     dump: { ...config.dump, pgDumpCommand }
   };
 }
 async function getAppliedFiles(config) {
-  const client = new Client2({
-    host: config.connection.host,
-    port: config.connection.port,
-    database: config.connection.database,
-    user: config.connection.user,
-    password: config.connection.password
-  });
+  const db = createDb(config);
   try {
-    await client.connect();
-    const result = await client.query(
-      `SELECT DISTINCT file_name FROM schema_migrations WHERE status IN ('applied', 'skipped')`
+    await db.connect();
+    await db.ensureTable();
+    const records = await db.getAllRecords();
+    return new Set(
+      records.filter((r) => r.status === "applied" || r.status === "skipped").map((r) => r.fileName)
     );
-    return new Set(result.rows.map((r) => r["file_name"]));
   } catch {
     return /* @__PURE__ */ new Set();
   } finally {
-    await client.end();
+    await db.close();
   }
 }
 async function verifyFile(file, sConfig, sDumpConfig) {
-  const firstApply = await executePsqlFile(sConfig, file.filePath);
+  const firstApply = await executeSqlFile(sConfig, file.filePath);
   if (!firstApply.success) {
-    return {
-      fileName: file.fileName,
-      passed: false,
-      firstApplyError: firstApply.stderr.trim()
-    };
+    return { fileName: file.fileName, passed: false, firstApplyError: firstApply.stderr.trim() };
   }
   const snapshot1 = await dumpSchema(sDumpConfig);
-  const secondApply = await executePsqlFile(sConfig, file.filePath);
+  const secondApply = await executeSqlFile(sConfig, file.filePath);
   if (!secondApply.success) {
-    return {
-      fileName: file.fileName,
-      passed: false,
-      secondApplyError: secondApply.stderr.trim()
-    };
+    return { fileName: file.fileName, passed: false, secondApplyError: secondApply.stderr.trim() };
   }
   const snapshot2 = await dumpSchema(sDumpConfig);
   const drift = snapshot1 !== snapshot2;
-  return {
-    fileName: file.fileName,
-    passed: !drift,
-    schemaDrift: drift || void 0
-  };
+  return { fileName: file.fileName, passed: !drift, schemaDrift: drift || void 0 };
 }
 async function commandVerify(config, options) {
   const allMode = options?.all ?? false;
-  const dbName = shadowDbName();
+  const id = shadowId();
+  const name = shadowName(config, id);
   const files = await scanMigrations(config);
   if (files.length === 0) {
     console.log(chalk.yellow("No migration files to verify."));
-    return { files: [], passed: 0, failed: 0, shadowDbName: dbName };
+    return { files: [], passed: 0, failed: 0, shadowDbName: name };
   }
   const results = [];
   console.log(chalk.bold(`
-Verifying idempotency using shadow DB: ${dbName}`));
+Verifying idempotency using shadow DB: ${name}`));
   if (allMode) {
     console.log(chalk.gray("  Mode: --all (verify all migrations from scratch)\n"));
   } else {
     console.log(chalk.gray("  Mode: incremental (restore current DB, verify pending)\n"));
   }
   try {
-    await createShadowDb(config.connection, dbName);
-    const sConfig = shadowConfig(config, dbName);
-    const sDumpConfig = shadowDumpConfig(config, dbName);
+    await createShadow(config, name);
+    const sConfig = buildShadowConfig(config, name);
+    const sDumpConfig = buildShadowDumpConfig(config, name);
     const verifiableFiles = files.filter((f) => f.phase !== "backfill");
     if (allMode) {
       for (const file of verifiableFiles) {
         const r = await verifyFile(file, sConfig, sDumpConfig);
         results.push(r);
-        if (r.passed) {
-          console.log(chalk.green(`  \u2713 ${file.fileName}`));
-        } else {
-          console.log(chalk.red(`  \u2717 ${file.fileName}`));
-          if (r.firstApplyError) console.log(chalk.red(`      1st apply error: ${r.firstApplyError}`));
-          if (r.secondApplyError) console.log(chalk.red(`      2nd apply error: ${r.secondApplyError}`));
-          if (r.schemaDrift) console.log(chalk.red(`      Schema changed between 1st and 2nd apply`));
-        }
+        printVerifyFileResult(r);
       }
     } else {
       console.log(chalk.blue("  Restoring current DB schema to shadow..."));
-      await dumpSourceToShadow(config, dbName);
+      await cloneSourceToShadow(config, name);
       console.log(chalk.green("  \u2713 Schema restored.\n"));
       const appliedFiles = await getAppliedFiles(config);
       const pendingFiles = verifiableFiles.filter((f) => !appliedFiles.has(f.fileName));
@@ -4659,21 +5086,14 @@ Verifying idempotency using shadow DB: ${dbName}`));
         for (const file of pendingFiles) {
           const r = await verifyFile(file, sConfig, sDumpConfig);
           results.push(r);
-          if (r.passed) {
-            console.log(chalk.green(`  \u2713 ${file.fileName}`));
-          } else {
-            console.log(chalk.red(`  \u2717 ${file.fileName}`));
-            if (r.firstApplyError) console.log(chalk.red(`      1st apply error: ${r.firstApplyError}`));
-            if (r.secondApplyError) console.log(chalk.red(`      2nd apply error: ${r.secondApplyError}`));
-            if (r.schemaDrift) console.log(chalk.red(`      Schema changed between 1st and 2nd apply`));
-          }
+          printVerifyFileResult(r);
         }
       }
     }
   } finally {
-    await dropShadowDb(config.connection, dbName);
+    await dropShadow(config, name);
     console.log(chalk.gray(`
-  Shadow DB "${dbName}" dropped.`));
+  Shadow DB "${name}" dropped.`));
   }
   const passed = results.filter((r) => r.passed).length;
   const failed = results.filter((r) => !r.passed).length;
@@ -4683,7 +5103,17 @@ Verifying idempotency using shadow DB: ${dbName}`));
   } else if (failed > 0) {
     console.log(chalk.red(`\u2717 ${failed}/${results.length} migration(s) failed idempotency check.`));
   }
-  return { files: results, passed, failed, shadowDbName: dbName };
+  return { files: results, passed, failed, shadowDbName: name };
+}
+function printVerifyFileResult(r) {
+  if (r.passed) {
+    console.log(chalk.green(`  \u2713 ${r.fileName}`));
+  } else {
+    console.log(chalk.red(`  \u2717 ${r.fileName}`));
+    if (r.firstApplyError) console.log(chalk.red(`      1st apply error: ${r.firstApplyError}`));
+    if (r.secondApplyError) console.log(chalk.red(`      2nd apply error: ${r.secondApplyError}`));
+    if (r.schemaDrift) console.log(chalk.red(`      Schema changed between 1st and 2nd apply`));
+  }
 }
 async function commandDeps(config, options = {}) {
   const graph = await buildDependencyGraph(config);