@db-bridge/core 1.0.0 → 1.1.3

package/dist/cli/index.js

@@ -0,0 +1,3000 @@
+#!/usr/bin/env node
+import { parseArgs } from 'util';
+import { resolve, basename, extname, join } from 'path';
+import { existsSync } from 'fs';
+import { pathToFileURL } from 'url';
+import { createHash } from 'crypto';
+import { mkdir, writeFile, readdir, readFile } from 'fs/promises';
+import { hostname } from 'os';
+
+var CONFIG_FILES = [
+  "db-bridge.config.ts",
+  "db-bridge.config.js",
+  "db-bridge.config.mjs",
+  "dbbridge.config.ts",
+  "dbbridge.config.js"
+];
+async function loadConfig(cwd = process.cwd()) {
+  let configPath = null;
+  for (const filename of CONFIG_FILES) {
+    const fullPath = resolve(cwd, filename);
+    if (existsSync(fullPath)) {
+      configPath = fullPath;
+      break;
+    }
+  }
+  if (!configPath) {
+    throw new Error(`Configuration file not found. Create one of: ${CONFIG_FILES.join(", ")}`);
+  }
+  try {
+    const fileUrl = pathToFileURL(configPath).href;
+    const module = await import(fileUrl);
+    const config = module.default || module;
+    validateConfig(config);
+    return applyDefaults(config);
+  } catch (error2) {
+    if (error2.message.includes("Configuration file not found")) {
+      throw error2;
+    }
+    throw new Error(`Failed to load config from ${configPath}: ${error2.message}`);
+  }
+}
+function validateConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("Configuration must be an object");
+  }
+  const cfg = config;
+  const connection = cfg["connection"];
+  if (!connection || typeof connection !== "object") {
+    throw new Error('Configuration must have a "connection" object');
+  }
+  const conn = connection;
+  const dialect = conn["dialect"];
+  const host = conn["host"];
+  const database = conn["database"];
+  if (!["mysql", "postgresql"].includes(dialect)) {
+    throw new Error('connection.dialect must be "mysql" or "postgresql"');
+  }
+  if (!host || typeof host !== "string") {
+    throw new Error("connection.host is required");
+  }
+  if (!database || typeof database !== "string") {
+    throw new Error("connection.database is required");
+  }
+}
+function applyDefaults(config) {
+  const defaultPort = config.connection.dialect === "mysql" ? 3306 : 5432;
+  return {
+    ...config,
+    connection: {
+      ...config.connection,
+      port: config.connection.port ?? defaultPort,
+      user: config.connection.user ?? "root",
+      password: config.connection.password ?? ""
+    },
+    migrations: {
+      directory: "./src/migrations",
+      tableName: "db_migrations",
+      lockTableName: "db_migrations_lock",
+      ...config.migrations
+    },
+    seeds: {
+      directory: "./src/seeds",
+      ...config.seeds
+    }
+  };
+}
+var MIGRATION_PATTERN = /^(\d{14})_(.+)\.(ts|js|mjs)$/;
+var MigrationLoader = class {
+  directory;
+  extensions;
+  constructor(directory, extensions = [".ts", ".js", ".mjs"]) {
+    this.directory = directory;
+    this.extensions = extensions;
+  }
+  /**
+   * Scan directory for migration files
+   */
+  async scanDirectory() {
+    const files = [];
+    try {
+      const entries = await readdir(this.directory, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile()) {
+          continue;
+        }
+        const ext = extname(entry.name);
+        if (!this.extensions.includes(ext)) {
+          continue;
+        }
+        const match = entry.name.match(MIGRATION_PATTERN);
+        if (!match) {
+          continue;
+        }
+        const [, timestamp, description] = match;
+        files.push({
+          name: basename(entry.name, ext),
+          path: join(this.directory, entry.name),
+          timestamp,
+          description: description.replaceAll("_", " ")
+        });
+      }
+      files.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+      return files;
+    } catch (error2) {
+      if (error2.code === "ENOENT") {
+        throw new Error(`Migration directory not found: ${this.directory}`);
+      }
+      throw error2;
+    }
+  }
+  /**
+   * Load a single migration file
+   */
+  async loadMigration(file) {
+    try {
+      const fileUrl = pathToFileURL(file.path).href;
+      const module = await import(fileUrl);
+      const migration = module.default || module;
+      if (typeof migration.up !== "function") {
+        throw new TypeError(`Migration ${file.name} is missing 'up' function`);
+      }
+      if (typeof migration.down !== "function") {
+        throw new TypeError(`Migration ${file.name} is missing 'down' function`);
+      }
+      return {
+        name: file.name,
+        up: migration.up,
+        down: migration.down,
+        transactional: migration.transactional ?? true,
+        phase: migration.phase
+      };
+    } catch (error2) {
+      throw new Error(`Failed to load migration ${file.name}: ${error2.message}`);
+    }
+  }
+  /**
+   * Load all migrations from directory
+   */
+  async loadAll() {
+    const files = await this.scanDirectory();
+    const migrations = [];
+    for (const file of files) {
+      const migration = await this.loadMigration(file);
+      migrations.push(migration);
+    }
+    return migrations;
+  }
+  /**
+   * Get migration files (metadata only, without loading)
+   */
+  async getMigrationFiles() {
+    return this.scanDirectory();
+  }
+  /**
+   * Calculate checksum for a migration file
+   */
+  async calculateChecksum(file) {
+    const content = await readFile(file.path, "utf8");
+    const normalized = content.replaceAll("\r\n", "\n").trim();
+    return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+  }
+  /**
+   * Calculate checksums for all migration files
+   */
+  async calculateAllChecksums() {
+    const files = await this.scanDirectory();
+    const checksums = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const checksum = await this.calculateChecksum(file);
+      checksums.set(file.name, checksum);
+    }
+    return checksums;
+  }
+  /**
+   * Generate a new migration filename
+   */
+  static generateFilename(description) {
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = [
+      now.getFullYear(),
+      String(now.getMonth() + 1).padStart(2, "0"),
+      String(now.getDate()).padStart(2, "0"),
+      String(now.getHours()).padStart(2, "0"),
+      String(now.getMinutes()).padStart(2, "0"),
+      String(now.getSeconds()).padStart(2, "0")
+    ].join("");
+    const sanitizedDescription = description.toLowerCase().replaceAll(/[^\da-z]+/g, "_").replaceAll(/^_+|_+$/g, "");
+    return `${timestamp}_${sanitizedDescription}.ts`;
+  }
+  /**
+   * Get migration template content
+   */
+  static getMigrationTemplate(name) {
+    return `/**
+ * Migration: ${name}
+ * Created at: ${(/* @__PURE__ */ new Date()).toISOString()}
+ */
+
+import type { SchemaBuilder } from '@db-bridge/core';
+
+export default {
+  name: '${name}',
+
+  async up(schema: SchemaBuilder): Promise<void> {
+    // Write your migration here
+    // Example:
+    // await schema.createTable('users', (table) => {
+    //   table.increments('id');
+    //   table.string('email', 255).unique().notNull();
+    //   table.timestamps();
+    // });
+  },
+
+  async down(schema: SchemaBuilder): Promise<void> {
+    // Reverse the migration
+    // Example:
+    // await schema.dropTableIfExists('users');
+  },
+};
+`;
+  }
+};
+
+// src/schema/dialects/MySQLDialect.ts
+var MySQLDialect = class {
+  dialect = "mysql";
+  /**
+   * Quote an identifier (table/column name)
+   */
+  quoteIdentifier(name) {
+    return `\`${name.replaceAll("`", "``")}\``;
+  }
+  /**
+   * Quote a value for SQL
+   */
+  quoteValue(value) {
+    if (value === null || value === void 0) {
+      return "NULL";
+    }
+    if (typeof value === "boolean") {
+      return value ? "1" : "0";
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "string") {
+      return `'${value.replaceAll("'", "''")}'`;
+    }
+    return `'${String(value).replaceAll("'", "''")}'`;
+  }
+  /**
+   * Generate CREATE TABLE statement
+   */
+  createTable(definition) {
+    const parts = [];
+    for (const column of definition.columns) {
+      parts.push(this.columnToSQL(column));
+    }
+    if (definition.primaryKey && definition.primaryKey.length > 0) {
+      const pkColumns = definition.primaryKey.map((c) => this.quoteIdentifier(c)).join(", ");
+      parts.push(`PRIMARY KEY (${pkColumns})`);
+    }
+    for (const index of definition.indexes) {
+      parts.push(this.indexToSQL(index));
+    }
+    for (const fk of definition.foreignKeys) {
+      parts.push(this.foreignKeyToSQL(fk));
+    }
+    let sql = `CREATE TABLE ${this.quoteIdentifier(definition.name)} (
+  ${parts.join(",\n  ")}
+)`;
+    const options = [];
+    if (definition.engine) {
+      options.push(`ENGINE=${definition.engine}`);
+    } else {
+      options.push("ENGINE=InnoDB");
+    }
+    if (definition.charset) {
+      options.push(`DEFAULT CHARSET=${definition.charset}`);
+    } else {
+      options.push("DEFAULT CHARSET=utf8mb4");
+    }
+    if (definition.collation) {
+      options.push(`COLLATE=${definition.collation}`);
+    }
+    if (definition.comment) {
+      options.push(`COMMENT=${this.quoteValue(definition.comment)}`);
+    }
+    if (options.length > 0) {
+      sql += ` ${options.join(" ")}`;
+    }
+    return sql;
+  }
+  /**
+   * Generate DROP TABLE statement
+   */
+  dropTable(tableName) {
+    return `DROP TABLE ${this.quoteIdentifier(tableName)}`;
+  }
+  /**
+   * Generate DROP TABLE IF EXISTS statement
+   */
+  dropTableIfExists(tableName) {
+    return `DROP TABLE IF EXISTS ${this.quoteIdentifier(tableName)}`;
+  }
+  /**
+   * Generate RENAME TABLE statement
+   */
+  renameTable(from, to) {
+    return `RENAME TABLE ${this.quoteIdentifier(from)} TO ${this.quoteIdentifier(to)}`;
+  }
+  /**
+   * Generate ALTER TABLE statements
+   */
+  alterTable(definition) {
+    const statements = [];
+    const tableName = this.quoteIdentifier(definition.tableName);
+    for (const op of definition.operations) {
+      switch (op.type) {
+        case "addColumn": {
+          statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${this.columnToSQL(op.column)}`);
+          break;
+        }
+        case "dropColumn": {
+          statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.quoteIdentifier(op.name)}`);
+          break;
+        }
+        case "renameColumn": {
+          statements.push(
+            `ALTER TABLE ${tableName} RENAME COLUMN ${this.quoteIdentifier(op.from)} TO ${this.quoteIdentifier(op.to)}`
+          );
+          break;
+        }
+        case "modifyColumn": {
+          statements.push(`ALTER TABLE ${tableName} MODIFY COLUMN ${this.columnToSQL(op.column)}`);
+          break;
+        }
+        case "addIndex": {
+          statements.push(`ALTER TABLE ${tableName} ADD ${this.indexToSQL(op.index)}`);
+          break;
+        }
+        case "dropIndex": {
+          statements.push(`ALTER TABLE ${tableName} DROP INDEX ${this.quoteIdentifier(op.name)}`);
+          break;
+        }
+        case "addForeignKey": {
+          statements.push(`ALTER TABLE ${tableName} ADD ${this.foreignKeyToSQL(op.foreignKey)}`);
+          break;
+        }
+        case "dropForeignKey": {
+          statements.push(
+            `ALTER TABLE ${tableName} DROP FOREIGN KEY ${this.quoteIdentifier(op.name)}`
+          );
+          break;
+        }
+        case "addPrimary": {
+          const pkCols = op.columns.map((c) => this.quoteIdentifier(c)).join(", ");
+          statements.push(`ALTER TABLE ${tableName} ADD PRIMARY KEY (${pkCols})`);
+          break;
+        }
+        case "dropPrimary": {
+          statements.push(`ALTER TABLE ${tableName} DROP PRIMARY KEY`);
+          break;
+        }
+      }
+    }
+    return statements;
+  }
+  /**
+   * Generate query to check if table exists
+   */
+  hasTable(tableName) {
+    return `SELECT 1 FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = ${this.quoteValue(tableName)} LIMIT 1`;
+  }
+  /**
+   * Generate query to check if column exists
+   */
+  hasColumn(tableName, columnName) {
+    return `SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = ${this.quoteValue(tableName)} AND column_name = ${this.quoteValue(columnName)} LIMIT 1`;
+  }
+  /**
+   * Convert column definition to SQL
+   */
+  columnToSQL(column) {
+    const parts = [this.quoteIdentifier(column.name)];
+    parts.push(this.columnTypeToSQL(column));
+    if (column.unsigned) {
+      parts.push("UNSIGNED");
+    }
+    if (column.nullable) {
+      parts.push("NULL");
+    } else {
+      parts.push("NOT NULL");
+    }
+    if (column.defaultRaw) {
+      parts.push(`DEFAULT ${column.defaultRaw}`);
+    } else if (column.defaultValue !== void 0) {
+      parts.push(`DEFAULT ${this.quoteValue(column.defaultValue)}`);
+    }
+    if (column.autoIncrement) {
+      parts.push("AUTO_INCREMENT");
+    }
+    if (column.primary && !column.autoIncrement) {
+      parts.push("PRIMARY KEY");
+    } else if (column.primary && column.autoIncrement) {
+      parts.push("PRIMARY KEY");
+    }
+    if (column.unique && !column.primary) {
+      parts.push("UNIQUE");
+    }
+    if (column.comment) {
+      parts.push(`COMMENT ${this.quoteValue(column.comment)}`);
+    }
+    if (column.first) {
+      parts.push("FIRST");
+    } else if (column.after) {
+      parts.push(`AFTER ${this.quoteIdentifier(column.after)}`);
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Convert column type to MySQL type
+   */
+  columnTypeToSQL(column) {
+    switch (column.type) {
+      case "increments": {
+        return "INT UNSIGNED AUTO_INCREMENT";
+      }
+      case "bigIncrements": {
+        return "BIGINT UNSIGNED AUTO_INCREMENT";
+      }
+      case "integer": {
+        return "INT";
+      }
+      case "bigInteger": {
+        return "BIGINT";
+      }
+      case "smallInteger": {
+        return "SMALLINT";
+      }
+      case "tinyInteger": {
+        return "TINYINT";
+      }
+      case "float": {
+        return "FLOAT";
+      }
+      case "double": {
+        return "DOUBLE";
+      }
+      case "decimal": {
+        const precision = column.precision ?? 10;
+        const scale = column.scale ?? 2;
+        return `DECIMAL(${precision},${scale})`;
+      }
+      case "string": {
+        return `VARCHAR(${column.length ?? 255})`;
+      }
+      case "text": {
+        return "TEXT";
+      }
+      case "mediumText": {
+        return "MEDIUMTEXT";
+      }
+      case "longText": {
+        return "LONGTEXT";
+      }
+      case "boolean": {
+        return "TINYINT(1)";
+      }
+      case "date": {
+        return "DATE";
+      }
+      case "datetime": {
+        return "DATETIME";
+      }
+      case "timestamp": {
+        return "TIMESTAMP";
+      }
+      case "time": {
+        return "TIME";
+      }
+      case "json":
+      case "jsonb": {
+        return "JSON";
+      }
+      case "uuid": {
+        return "CHAR(36)";
+      }
+      case "binary": {
+        return "BLOB";
+      }
+      case "enum": {
+        if (column.enumValues && column.enumValues.length > 0) {
+          const values = column.enumValues.map((v) => this.quoteValue(v)).join(", ");
+          return `ENUM(${values})`;
+        }
+        return "VARCHAR(255)";
+      }
+      default: {
+        return "VARCHAR(255)";
+      }
+    }
+  }
+  /**
+   * Convert index definition to SQL
+   */
+  indexToSQL(index) {
+    const columns = index.columns.map((c) => this.quoteIdentifier(c)).join(", ");
+    const name = index.name ? this.quoteIdentifier(index.name) : "";
+    if (index.type === "fulltext") {
+      return `FULLTEXT INDEX ${name} (${columns})`;
+    }
+    if (index.unique) {
+      return `UNIQUE INDEX ${name} (${columns})`;
+    }
+    return `INDEX ${name} (${columns})`;
+  }
+  /**
+   * Convert foreign key definition to SQL
+   */
+  foreignKeyToSQL(fk) {
+    const parts = ["CONSTRAINT"];
+    if (fk.name) {
+      parts.push(this.quoteIdentifier(fk.name));
+    }
+    parts.push(`FOREIGN KEY (${this.quoteIdentifier(fk.column)})`);
+    parts.push(
+      `REFERENCES ${this.quoteIdentifier(fk.table)} (${this.quoteIdentifier(fk.referenceColumn)})`
+    );
+    if (fk.onDelete) {
+      parts.push(`ON DELETE ${fk.onDelete}`);
+    }
+    if (fk.onUpdate) {
+      parts.push(`ON UPDATE ${fk.onUpdate}`);
+    }
+    return parts.join(" ");
+  }
+};
+
+// src/schema/dialects/PostgreSQLDialect.ts
+var PostgreSQLDialect = class {
+  dialect = "postgresql";
+  /**
+   * Quote an identifier (table/column name)
+   */
+  quoteIdentifier(name) {
+    return `"${name.replaceAll('"', '""')}"`;
+  }
+  /**
+   * Quote a value for SQL
+   */
+  quoteValue(value) {
+    if (value === null || value === void 0) {
+      return "NULL";
+    }
+    if (typeof value === "boolean") {
+      return value ? "TRUE" : "FALSE";
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "string") {
+      return `'${value.replaceAll("'", "''")}'`;
+    }
+    return `'${String(value).replaceAll("'", "''")}'`;
+  }
+  /**
+   * Generate CREATE TABLE statement
+   */
+  createTable(definition) {
+    const parts = [];
+    for (const column of definition.columns) {
+      parts.push(this.columnToSQL(column));
+    }
+    if (definition.primaryKey && definition.primaryKey.length > 0) {
+      const pkColumns = definition.primaryKey.map((c) => this.quoteIdentifier(c)).join(", ");
+      parts.push(`PRIMARY KEY (${pkColumns})`);
+    }
+    for (const fk of definition.foreignKeys) {
+      parts.push(this.foreignKeyToSQL(fk));
+    }
+    const sql = `CREATE TABLE ${this.quoteIdentifier(definition.name)} (
+  ${parts.join(",\n  ")}
+)`;
+    const statements = [sql];
+    if (definition.comment) {
+      statements.push(
+        `COMMENT ON TABLE ${this.quoteIdentifier(definition.name)} IS ${this.quoteValue(definition.comment)}`
+      );
+    }
+    return statements.join(";\n");
+  }
+  /**
+   * Generate DROP TABLE statement
+   */
+  dropTable(tableName) {
+    return `DROP TABLE ${this.quoteIdentifier(tableName)}`;
+  }
+  /**
+   * Generate DROP TABLE IF EXISTS statement
+   */
+  dropTableIfExists(tableName) {
+    return `DROP TABLE IF EXISTS ${this.quoteIdentifier(tableName)}`;
+  }
+  /**
+   * Generate ALTER TABLE ... RENAME statement
+   */
+  renameTable(from, to) {
+    return `ALTER TABLE ${this.quoteIdentifier(from)} RENAME TO ${this.quoteIdentifier(to)}`;
+  }
+  /**
+   * Generate ALTER TABLE statements
+   */
+  alterTable(definition) {
+    const statements = [];
+    const tableName = this.quoteIdentifier(definition.tableName);
+    for (const op of definition.operations) {
+      switch (op.type) {
+        case "addColumn": {
+          statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${this.columnToSQL(op.column)}`);
+          break;
+        }
+        case "dropColumn": {
+          statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.quoteIdentifier(op.name)}`);
+          break;
+        }
+        case "renameColumn": {
+          statements.push(
+            `ALTER TABLE ${tableName} RENAME COLUMN ${this.quoteIdentifier(op.from)} TO ${this.quoteIdentifier(op.to)}`
+          );
+          break;
+        }
+        case "modifyColumn": {
+          const col = op.column;
+          statements.push(
+            `ALTER TABLE ${tableName} ALTER COLUMN ${this.quoteIdentifier(col.name)} TYPE ${this.columnTypeToSQL(col)}`
+          );
+          if (col.nullable) {
+            statements.push(
+              `ALTER TABLE ${tableName} ALTER COLUMN ${this.quoteIdentifier(col.name)} DROP NOT NULL`
+            );
+          } else {
+            statements.push(
+              `ALTER TABLE ${tableName} ALTER COLUMN ${this.quoteIdentifier(col.name)} SET NOT NULL`
+            );
+          }
+          if (col.defaultRaw) {
+            statements.push(
+              `ALTER TABLE ${tableName} ALTER COLUMN ${this.quoteIdentifier(col.name)} SET DEFAULT ${col.defaultRaw}`
+            );
+          } else if (col.defaultValue !== void 0) {
+            statements.push(
+              `ALTER TABLE ${tableName} ALTER COLUMN ${this.quoteIdentifier(col.name)} SET DEFAULT ${this.quoteValue(col.defaultValue)}`
+            );
+          }
+          break;
+        }
+        case "addIndex": {
+          statements.push(this.createIndex(definition.tableName, op.index));
+          break;
+        }
+        case "dropIndex": {
+          statements.push(`DROP INDEX ${this.quoteIdentifier(op.name)}`);
+          break;
+        }
+        case "addForeignKey": {
+          statements.push(`ALTER TABLE ${tableName} ADD ${this.foreignKeyToSQL(op.foreignKey)}`);
+          break;
+        }
+        case "dropForeignKey": {
+          statements.push(
+            `ALTER TABLE ${tableName} DROP CONSTRAINT ${this.quoteIdentifier(op.name)}`
+          );
+          break;
+        }
+        case "addPrimary": {
+          const pkCols = op.columns.map((c) => this.quoteIdentifier(c)).join(", ");
+          statements.push(`ALTER TABLE ${tableName} ADD PRIMARY KEY (${pkCols})`);
+          break;
+        }
+        case "dropPrimary": {
+          statements.push(
+            `ALTER TABLE ${tableName} DROP CONSTRAINT ${this.quoteIdentifier(`${definition.tableName}_pkey`)}`
+          );
+          break;
+        }
+      }
+    }
+    return statements;
+  }
+  /**
+   * Generate query to check if table exists
+   */
+  hasTable(tableName) {
+    return `SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = ${this.quoteValue(tableName)} LIMIT 1`;
+  }
+  /**
+   * Generate query to check if column exists
+   */
+  hasColumn(tableName, columnName) {
+    return `SELECT 1 FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ${this.quoteValue(tableName)} AND column_name = ${this.quoteValue(columnName)} LIMIT 1`;
+  }
+  /**
+   * Create index statement
+   */
+  createIndex(tableName, index) {
+    const columns = index.columns.map((c) => this.quoteIdentifier(c)).join(", ");
+    const indexName = index.name || `idx_${tableName}_${index.columns.join("_")}`;
+    const unique = index.unique ? "UNIQUE " : "";
+    return `CREATE ${unique}INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)} (${columns})`;
+  }
+  /**
+   * Convert column definition to SQL
+   */
+  columnToSQL(column) {
+    const parts = [this.quoteIdentifier(column.name)];
+    parts.push(this.columnTypeToSQL(column));
+    if (!column.nullable) {
+      parts.push("NOT NULL");
+    }
+    if (column.defaultRaw) {
+      parts.push(`DEFAULT ${column.defaultRaw}`);
+    } else if (column.defaultValue !== void 0) {
+      parts.push(`DEFAULT ${this.quoteValue(column.defaultValue)}`);
+    }
+    if (column.primary && column.type !== "increments" && column.type !== "bigIncrements") {
+      parts.push("PRIMARY KEY");
+    }
+    if (column.unique && !column.primary) {
+      parts.push("UNIQUE");
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Convert column type to PostgreSQL type
+   */
+  columnTypeToSQL(column) {
+    switch (column.type) {
+      case "increments": {
+        return "SERIAL PRIMARY KEY";
+      }
+      case "bigIncrements": {
+        return "BIGSERIAL PRIMARY KEY";
+      }
+      case "integer": {
+        return "INTEGER";
+      }
+      case "bigInteger": {
+        return "BIGINT";
+      }
+      case "smallInteger": {
+        return "SMALLINT";
+      }
+      case "tinyInteger": {
+        return "SMALLINT";
+      }
+      // PostgreSQL doesn't have TINYINT
+      case "float": {
+        return "REAL";
+      }
+      case "double": {
+        return "DOUBLE PRECISION";
+      }
+      case "decimal": {
+        const precision = column.precision ?? 10;
+        const scale = column.scale ?? 2;
+        return `NUMERIC(${precision},${scale})`;
+      }
+      case "string": {
+        return `VARCHAR(${column.length ?? 255})`;
+      }
+      case "text":
+      case "mediumText":
+      case "longText": {
+        return "TEXT";
+      }
+      case "boolean": {
+        return "BOOLEAN";
+      }
+      case "date": {
+        return "DATE";
+      }
+      case "datetime":
+      case "timestamp": {
+        return "TIMESTAMP";
+      }
+      case "time": {
+        return "TIME";
+      }
+      case "json": {
+        return "JSON";
+      }
+      case "jsonb": {
+        return "JSONB";
+      }
+      case "uuid": {
+        return "UUID";
+      }
+      case "binary": {
+        return "BYTEA";
+      }
+      case "enum": {
+        if (column.enumValues && column.enumValues.length > 0) {
+          const values = column.enumValues.map((v) => this.quoteValue(v)).join(", ");
+          return `VARCHAR(255) CHECK (${this.quoteIdentifier(column.name)} IN (${values}))`;
+        }
+        return "VARCHAR(255)";
+      }
+      default: {
+        return "VARCHAR(255)";
+      }
+    }
+  }
+  /**
+   * Convert foreign key definition to SQL
+   */
+  foreignKeyToSQL(fk) {
+    const parts = ["CONSTRAINT"];
+    if (fk.name) {
+      parts.push(this.quoteIdentifier(fk.name));
+    } else {
+      parts.push(this.quoteIdentifier(`fk_${fk.column}_${fk.table}`));
+    }
+    parts.push(`FOREIGN KEY (${this.quoteIdentifier(fk.column)})`);
+    parts.push(
+      `REFERENCES ${this.quoteIdentifier(fk.table)} (${this.quoteIdentifier(fk.referenceColumn)})`
+    );
+    if (fk.onDelete) {
+      parts.push(`ON DELETE ${fk.onDelete}`);
+    }
+    if (fk.onUpdate) {
+      parts.push(`ON UPDATE ${fk.onUpdate}`);
+    }
+    return parts.join(" ");
+  }
+};
+
+// src/migrations/MigrationLock.ts
+var MigrationLock = class {
+  adapter;
+  tableName;
+  timeout;
+  dialect;
+  lockId;
+  isLocked = false;
+  constructor(adapter, options) {
+    this.adapter = adapter;
+    this.tableName = options.tableName ?? "db_migrations_lock";
+    this.timeout = options.timeout ?? 6e4;
+    this.lockId = `${hostname()}_${process.pid}_${Date.now()}`;
+    this.dialect = options.dialect === "mysql" ? new MySQLDialect() : new PostgreSQLDialect();
+  }
+  /**
+   * Initialize the lock table
+   */
+  async initialize() {
+    const tableName = this.dialect.quoteIdentifier(this.tableName);
+    if (this.dialect.dialect === "mysql") {
+      await this.adapter.execute(`
+        CREATE TABLE IF NOT EXISTS ${tableName} (
+          id INT PRIMARY KEY,
+          is_locked TINYINT NOT NULL DEFAULT 0,
+          locked_at TIMESTAMP NULL,
+          locked_by VARCHAR(255) NULL
+        ) ENGINE=InnoDB
+      `);
+    } else {
+      await this.adapter.execute(`
+        CREATE TABLE IF NOT EXISTS ${tableName} (
+          id INT PRIMARY KEY,
+          is_locked BOOLEAN NOT NULL DEFAULT FALSE,
+          locked_at TIMESTAMP NULL,
+          locked_by VARCHAR(255) NULL
+        )
+      `);
+    }
+    const checkSql = this.dialect.dialect === "mysql" ? `SELECT 1 FROM ${tableName} WHERE id = 1` : `SELECT 1 FROM ${tableName} WHERE id = 1`;
+    const result = await this.adapter.query(checkSql);
+    if (result.rows.length === 0) {
+      if (this.dialect.dialect === "mysql") {
+        await this.adapter.execute(`INSERT INTO ${tableName} (id, is_locked) VALUES (1, 0)`);
+      } else {
+        await this.adapter.execute(`INSERT INTO ${tableName} (id, is_locked) VALUES (1, FALSE)`);
+      }
+    }
+  }
+  /**
+   * Acquire the migration lock
+   */
+  async acquire() {
+    const tableName = this.dialect.quoteIdentifier(this.tableName);
+    const startTime = Date.now();
+    while (Date.now() - startTime < this.timeout) {
+      try {
+        if (this.dialect.dialect === "mysql") {
+          const result = await this.adapter.execute(
+            `
+            UPDATE ${tableName}
+            SET is_locked = 1,
+                locked_at = NOW(),
+                locked_by = ?
+            WHERE id = 1 AND is_locked = 0
+          `,
+            [this.lockId]
+          );
+          if ((result.affectedRows ?? 0) > 0) {
+            this.isLocked = true;
+            return true;
+          }
+        } else {
+          const result = await this.adapter.execute(
+            `
+            UPDATE ${tableName}
+            SET is_locked = TRUE,
+                locked_at = NOW(),
+                locked_by = $1
+            WHERE id = 1 AND is_locked = FALSE
+            RETURNING id
+          `,
+            [this.lockId]
+          );
+          if (result.rows.length > 0) {
+            this.isLocked = true;
+            return true;
+          }
+        }
+        const staleResult = await this.adapter.query(`SELECT locked_at, locked_by FROM ${tableName} WHERE id = 1`);
+        if (staleResult.rows.length > 0) {
+          const lockedAt = staleResult.rows[0].locked_at;
+          if (lockedAt && Date.now() - new Date(lockedAt).getTime() > this.timeout) {
+            console.warn(
+              `Releasing stale migration lock held by ${staleResult.rows[0].locked_by}`
+            );
+            await this.forceRelease();
+            continue;
+          }
+        }
+        await this.sleep(1e3);
+      } catch (error2) {
+        console.error("Error acquiring migration lock:", error2);
+        throw error2;
+      }
+    }
+    return false;
+  }
+  /**
+   * Release the migration lock
+   */
+  async release() {
+    if (!this.isLocked) {
+      return;
+    }
+    const tableName = this.dialect.quoteIdentifier(this.tableName);
+    try {
+      if (this.dialect.dialect === "mysql") {
+        await this.adapter.execute(
+          `
+          UPDATE ${tableName}
+          SET is_locked = 0,
+              locked_at = NULL,
+              locked_by = NULL
+          WHERE id = 1 AND locked_by = ?
+        `,
+          [this.lockId]
+        );
+      } else {
+        await this.adapter.execute(
+          `
+          UPDATE ${tableName}
+          SET is_locked = FALSE,
+              locked_at = NULL,
+              locked_by = NULL
+          WHERE id = 1 AND locked_by = $1
+        `,
+          [this.lockId]
+        );
+      }
+      this.isLocked = false;
+    } catch (error2) {
+      console.error("Error releasing migration lock:", error2);
+      throw error2;
+    }
+  }
+  /**
+   * Force release the lock (for stale locks)
+   */
+  async forceRelease() {
+    const tableName = this.dialect.quoteIdentifier(this.tableName);
+    if (this.dialect.dialect === "mysql") {
+      await this.adapter.execute(`
+        UPDATE ${tableName}
+        SET is_locked = 0,
+            locked_at = NULL,
+            locked_by = NULL
+        WHERE id = 1
+      `);
+    } else {
+      await this.adapter.execute(`
+        UPDATE ${tableName}
+        SET is_locked = FALSE,
+            locked_at = NULL,
+            locked_by = NULL
+        WHERE id = 1
+      `);
+    }
+    this.isLocked = false;
+  }
+  /**
+   * Check if lock is currently held
+   */
+  async isHeld() {
+    const tableName = this.dialect.quoteIdentifier(this.tableName);
+    const result = await this.adapter.query(
+      `SELECT is_locked FROM ${tableName} WHERE id = 1`
+    );
+    if (result.rows.length === 0) {
+      return false;
+    }
+    const isLocked = result.rows[0].is_locked;
+    return isLocked === 1 || isLocked === true;
+  }
+  /**
+   * Get lock info
+   */
+  async getLockInfo() {
+    const tableName = this.dialect.quoteIdentifier(this.tableName);
+    const result = await this.adapter.query(`SELECT is_locked, locked_at, locked_by FROM ${tableName} WHERE id = 1`);
+    if (result.rows.length === 0) {
+      return { isLocked: false, lockedAt: null, lockedBy: null };
+    }
+    const row = result.rows[0];
+    return {
+      isLocked: row.is_locked === 1 || row.is_locked === true,
+      lockedAt: row.locked_at,
+      lockedBy: row.locked_by
+    };
+  }
+  /**
+   * Execute a function with lock
+   */
+  async withLock(fn) {
+    const acquired = await this.acquire();
+    if (!acquired) {
+      throw new Error(
+        `Could not acquire migration lock within ${this.timeout}ms. Another migration may be running.`
+      );
+    }
+    try {
+      return await fn();
+    } finally {
+      await this.release();
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve7) => setTimeout(resolve7, ms));
+  }
+};
+
+// src/schema/ColumnBuilder.ts
+var ColumnBuilder = class {
+  definition;
+  constructor(name, type) {
+    this.definition = {
+      name,
+      type,
+      nullable: type !== "increments" && type !== "bigIncrements",
+      unsigned: false,
+      autoIncrement: type === "increments" || type === "bigIncrements",
+      primary: type === "increments" || type === "bigIncrements",
+      unique: false,
+      index: false,
+      first: false
+    };
+  }
+  /**
+   * Set column length (for string types)
+   */
+  length(length) {
+    this.definition.length = length;
+    return this;
+  }
+  /**
+   * Set precision and scale (for decimal types)
+   */
+  precision(precision, scale) {
+    this.definition.precision = precision;
+    this.definition.scale = scale;
+    return this;
+  }
+  /**
+   * Mark column as nullable
+   */
+  nullable() {
+    this.definition.nullable = true;
+    return this;
+  }
+  /**
+   * Mark column as not nullable
+   */
+  notNull() {
+    this.definition.nullable = false;
+    return this;
+  }
+  /**
+   * Alias for notNull()
+   */
+  notNullable() {
+    return this.notNull();
+  }
+  /**
+   * Set default value
+   */
+  default(value) {
+    this.definition.defaultValue = value;
+    return this;
+  }
+  /**
+   * Set default value as raw SQL
+   */
+  defaultRaw(sql) {
+    this.definition.defaultRaw = sql;
+    return this;
+  }
+  /**
+   * Set default to current timestamp
+   */
+  defaultNow() {
+    this.definition.defaultRaw = "CURRENT_TIMESTAMP";
+    return this;
+  }
+  /**
+   * Mark column as unsigned (MySQL)
+   */
+  unsigned() {
+    this.definition.unsigned = true;
+    return this;
+  }
+  /**
+   * Mark column as auto increment
+   */
+  autoIncrement() {
+    this.definition.autoIncrement = true;
+    return this;
+  }
+  /**
+   * Mark column as primary key
+   */
+  primary() {
+    this.definition.primary = true;
+    return this;
+  }
+  /**
+   * Mark column as unique
+   */
+  unique() {
+    this.definition.unique = true;
+    return this;
+  }
+  /**
+   * Add index to column
+   */
+  index() {
+    this.definition.index = true;
+    return this;
+  }
+  /**
+   * Add comment to column
+   */
+  comment(comment) {
+    this.definition.comment = comment;
+    return this;
+  }
+  /**
+   * Position column after another column (MySQL)
+   */
+  after(columnName) {
+    this.definition.after = columnName;
+    return this;
+  }
+  /**
+   * Position column first (MySQL)
+   */
+  first() {
+    this.definition.first = true;
+    return this;
+  }
+  /**
+   * Set enum values
+   */
+  values(values) {
+    this.definition.enumValues = values;
+    return this;
+  }
+  /**
+   * Add foreign key reference
+   */
+  references(column) {
+    const fkBuilder = new ForeignKeyBuilder(this, column);
+    return fkBuilder;
+  }
+  /**
+   * Set foreign key definition (internal)
+   */
+  setForeignKey(fk) {
+    this.definition.references = fk;
+  }
+  /**
+   * Get the column definition
+   */
+  getDefinition() {
+    return { ...this.definition };
+  }
+};
+var ForeignKeyBuilder = class {
+  columnBuilder;
+  fkDefinition;
+  constructor(columnBuilder, referenceColumn) {
+    this.columnBuilder = columnBuilder;
+    this.fkDefinition = {
+      column: columnBuilder.getDefinition().name,
+      referenceColumn
+    };
+  }
+  /**
+   * Set the referenced table
+   */
+  on(tableName) {
+    this.fkDefinition.table = tableName;
+    this.applyToColumn();
+    return this;
+  }
+  /**
+   * Alias for on()
+   */
+  inTable(tableName) {
+    return this.on(tableName);
+  }
+  /**
+   * Set ON DELETE action
+   */
+  onDelete(action) {
+    this.fkDefinition.onDelete = action;
+    this.applyToColumn();
+    return this;
+  }
+  /**
+   * Set ON UPDATE action
+   */
+  onUpdate(action) {
+    this.fkDefinition.onUpdate = action;
+    this.applyToColumn();
+    return this;
+  }
+  /**
+   * Set constraint name
+   */
+  name(name) {
+    this.fkDefinition.name = name;
+    this.applyToColumn();
+    return this;
+  }
+  /**
+   * Apply the foreign key definition to the column
+   */
+  applyToColumn() {
+    if (this.fkDefinition.table && this.fkDefinition.referenceColumn) {
+      this.columnBuilder.setForeignKey(this.fkDefinition);
+    }
+  }
+  /**
+   * Get the column builder for chaining
+   */
+  getColumnBuilder() {
+    return this.columnBuilder;
+  }
+};
+
+// src/schema/TableBuilder.ts
+var TableBuilder = class {
+  tableName;
+  columns = [];
+  indexes = [];
+  foreignKeys = [];
+  primaryKeyColumns;
+  tableEngine;
+  tableCharset;
+  tableCollation;
+  tableComment;
+  constructor(tableName) {
+    this.tableName = tableName;
+  }
+  // ============================================
+  // Column Types
+  // ============================================
+  /**
+   * Auto-incrementing integer primary key
+   */
+  increments(name = "id") {
+    return this.addColumn(name, "increments");
+  }
+  /**
+   * Auto-incrementing big integer primary key
+   */
+  bigIncrements(name = "id") {
+    return this.addColumn(name, "bigIncrements");
+  }
+  /**
+   * Integer column
+   */
+  integer(name) {
+    return this.addColumn(name, "integer");
+  }
+  /**
+   * Big integer column
+   */
+  bigInteger(name) {
+    return this.addColumn(name, "bigInteger");
+  }
+  /**
+   * Small integer column
+   */
+  smallInteger(name) {
+    return this.addColumn(name, "smallInteger");
+  }
+  /**
+   * Tiny integer column
+   */
+  tinyInteger(name) {
+    return this.addColumn(name, "tinyInteger");
+  }
+  /**
+   * Float column
+   */
+  float(name) {
+    return this.addColumn(name, "float");
+  }
+  /**
+   * Double column
+   */
+  double(name) {
+    return this.addColumn(name, "double");
+  }
+  /**
+   * Decimal column
+   */
+  decimal(name, precision = 10, scale = 2) {
+    return this.addColumn(name, "decimal").precision(precision, scale);
+  }
+  /**
+   * String (VARCHAR) column
+   */
+  string(name, length = 255) {
+    return this.addColumn(name, "string").length(length);
+  }
+  /**
+   * Text column
+   */
+  text(name) {
+    return this.addColumn(name, "text");
+  }
+  /**
+   * Medium text column
+   */
+  mediumText(name) {
+    return this.addColumn(name, "mediumText");
+  }
+  /**
+   * Long text column
+   */
+  longText(name) {
+    return this.addColumn(name, "longText");
+  }
+  /**
+   * Boolean column
+   */
+  boolean(name) {
+    return this.addColumn(name, "boolean");
+  }
+  /**
+   * Date column
+   */
+  date(name) {
+    return this.addColumn(name, "date");
+  }
+  /**
+   * Datetime column
+   */
+  datetime(name) {
+    return this.addColumn(name, "datetime");
+  }
+  /**
+   * Timestamp column
+   */
+  timestamp(name) {
+    return this.addColumn(name, "timestamp");
+  }
+  /**
+   * Time column
+   */
+  time(name) {
+    return this.addColumn(name, "time");
+  }
+  /**
+   * JSON column
+   */
+  json(name) {
+    return this.addColumn(name, "json");
+  }
+  /**
+   * JSONB column (PostgreSQL)
+   */
+  jsonb(name) {
+    return this.addColumn(name, "jsonb");
+  }
+  /**
+   * UUID column
+   */
+  uuid(name) {
+    return this.addColumn(name, "uuid");
+  }
+  /**
+   * Binary column
+   */
+  binary(name) {
+    return this.addColumn(name, "binary");
+  }
+  /**
+   * Enum column
+   */
+  enum(name, values) {
+    return this.addColumn(name, "enum").values(values);
+  }
+  // ============================================
+  // Shortcut Methods
+  // ============================================
+  /**
+   * Add created_at and updated_at timestamp columns
+   */
+  timestamps() {
+    this.timestamp("created_at").notNull().defaultNow();
+    this.timestamp("updated_at").notNull().defaultNow();
+  }
+  /**
+   * Add deleted_at timestamp column for soft deletes
+   */
+  softDeletes() {
+    return this.timestamp("deleted_at").nullable();
+  }
+  /**
+   * Add foreign id column with foreign key
+   */
+  foreignId(name) {
+    const tableName = `${name.replace(/_id$/, "")}s`;
+    const column = this.integer(name).unsigned().notNull();
+    this.foreign(name).references("id").on(tableName);
+    return column;
+  }
+  /**
+   * Add UUID primary key column
+   */
+  uuidPrimary(name = "id") {
+    return this.uuid(name).primary().notNull();
+  }
+  // ============================================
+  // Indexes
+  // ============================================
+  /**
+   * Add an index
+   */
+  index(columns, name) {
+    const columnArray = Array.isArray(columns) ? columns : [columns];
+    this.indexes.push({
+      name: name || `idx_${this.tableName}_${columnArray.join("_")}`,
+      columns: columnArray,
+      unique: false
+    });
+    return this;
+  }
+  /**
+   * Add a unique index
+   */
+  unique(columns, name) {
+    const columnArray = Array.isArray(columns) ? columns : [columns];
+    this.indexes.push({
+      name: name || `uniq_${this.tableName}_${columnArray.join("_")}`,
+      columns: columnArray,
+      unique: true
+    });
+    return this;
+  }
+  /**
+   * Add a fulltext index (MySQL)
+   */
+  fulltext(columns, name) {
+    const columnArray = Array.isArray(columns) ? columns : [columns];
+    this.indexes.push({
+      name: name || `ft_${this.tableName}_${columnArray.join("_")}`,
+      columns: columnArray,
+      unique: false,
+      type: "fulltext"
+    });
+    return this;
+  }
+  /**
+   * Set primary key columns
+   */
+  primary(columns) {
+    this.primaryKeyColumns = Array.isArray(columns) ? columns : [columns];
+    return this;
+  }
+  // ============================================
+  // Foreign Keys
+  // ============================================
+  /**
+   * Add a foreign key constraint
+   */
+  foreign(column) {
+    return new ForeignKeyChain(this, column);
+  }
+  /**
+   * Add foreign key (internal)
+   */
+  addForeignKey(fk) {
+    this.foreignKeys.push(fk);
+  }
+  // ============================================
+  // Table Options
+  // ============================================
+  /**
+   * Set table engine (MySQL)
+   */
+  engine(engine) {
+    this.tableEngine = engine;
+    return this;
+  }
+  /**
+   * Set table charset (MySQL)
+   */
+  charset(charset) {
+    this.tableCharset = charset;
+    return this;
+  }
+  /**
+   * Set table collation (MySQL)
+   */
+  collation(collation) {
+    this.tableCollation = collation;
+    return this;
+  }
+  /**
+   * Set table comment
+   */
+  comment(comment) {
+    this.tableComment = comment;
+    return this;
+  }
+  // ============================================
+  // Internal Methods
+  // ============================================
+  /**
+   * Add a column and return its builder
+   */
+  addColumn(name, type) {
+    const builder = new ColumnBuilder(name, type);
+    this.columns.push(builder.getDefinition());
+    const index = this.columns.length - 1;
+    const proxy = new Proxy(builder, {
+      get: (target, prop, receiver) => {
+        const result = Reflect.get(target, prop, receiver);
+        if (typeof result === "function") {
+          return (...args) => {
+            const returnValue = result.apply(target, args);
+            this.columns[index] = target.getDefinition();
+            return returnValue === target ? proxy : returnValue;
+          };
+        }
+        return result;
+      }
+    });
+    return proxy;
+  }
+  /**
+   * Get the table definition
+   */
+  getDefinition() {
+    return {
+      name: this.tableName,
+      columns: [...this.columns],
+      indexes: [...this.indexes],
+      foreignKeys: [...this.foreignKeys],
+      primaryKey: this.primaryKeyColumns,
+      engine: this.tableEngine,
+      charset: this.tableCharset,
+      collation: this.tableCollation,
+      comment: this.tableComment
+    };
+  }
+};
+var ForeignKeyChain = class {
+  tableBuilder;
+  fkDefinition;
+  constructor(tableBuilder, column) {
+    this.tableBuilder = tableBuilder;
+    this.fkDefinition = { column };
+  }
+  /**
+   * Set the referenced column
+   */
+  references(column) {
+    this.fkDefinition.referenceColumn = column;
+    return this;
+  }
+  /**
+   * Set the referenced table
+   */
+  on(tableName) {
+    this.fkDefinition.table = tableName;
+    this.apply();
+    return this;
+  }
+  /**
+   * Alias for on()
+   */
+  inTable(tableName) {
+    return this.on(tableName);
+  }
+  /**
+   * Set ON DELETE action
+   */
+  onDelete(action) {
+    this.fkDefinition.onDelete = action;
+    this.apply();
+    return this;
+  }
+  /**
+   * Set ON UPDATE action
+   */
+  onUpdate(action) {
+    this.fkDefinition.onUpdate = action;
+    this.apply();
+    return this;
+  }
+  /**
+   * Set constraint name
+   */
+  name(name) {
+    this.fkDefinition.name = name;
+    this.apply();
+    return this;
+  }
+  /**
+   * Apply the foreign key to the table
+   */
+  apply() {
+    if (this.fkDefinition.column && this.fkDefinition.table && this.fkDefinition.referenceColumn) {
+      if (!this.fkDefinition.name) {
+        this.fkDefinition.name = `fk_${this.fkDefinition.column}_${this.fkDefinition.table}`;
+      }
+      this.tableBuilder.addForeignKey(this.fkDefinition);
+    }
+  }
+};
+
+// src/schema/SchemaBuilder.ts
+var SchemaBuilder = class {
+  dialectInstance;
+  adapter;
+  constructor(options) {
+    this.adapter = options.adapter;
+    switch (options.dialect) {
+      case "mysql": {
+        this.dialectInstance = new MySQLDialect();
+        break;
+      }
+      case "postgresql": {
+        this.dialectInstance = new PostgreSQLDialect();
+        break;
+      }
+      default: {
+        throw new Error(`Unsupported dialect: ${options.dialect}`);
+      }
+    }
+  }
+  /**
+   * Get the dialect instance
+   */
+  get dialect() {
+    return this.dialectInstance;
+  }
+  /**
+   * Create a new table
+   */
+  async createTable(tableName, callback) {
+    const builder = new TableBuilder(tableName);
+    callback(builder);
+    const definition = builder.getDefinition();
+    const sql = this.dialectInstance.createTable(definition);
+    await this.execute(sql);
+    if (this.dialectInstance.dialect === "postgresql" && definition.indexes.length > 0) {
+      const pgDialect = this.dialectInstance;
+      for (const index of definition.indexes) {
+        const indexSql = pgDialect.createIndex(tableName, index);
+        await this.execute(indexSql);
+      }
+    }
+  }
+  /**
+   * Create a table if it doesn't exist
+   */
+  async createTableIfNotExists(tableName, callback) {
+    const exists = await this.hasTable(tableName);
+    if (!exists) {
+      await this.createTable(tableName, callback);
+    }
+  }
+  /**
+   * Drop a table
+   */
+  async dropTable(tableName) {
+    const sql = this.dialectInstance.dropTable(tableName);
+    await this.execute(sql);
+  }
+  /**
+   * Drop a table if it exists
+   */
+  async dropTableIfExists(tableName) {
+    const sql = this.dialectInstance.dropTableIfExists(tableName);
+    await this.execute(sql);
+  }
+  /**
+   * Rename a table
+   */
+  async renameTable(from, to) {
+    const sql = this.dialectInstance.renameTable(from, to);
+    await this.execute(sql);
+  }
+  /**
+   * Check if a table exists
+   */
+  async hasTable(tableName) {
+    const sql = this.dialectInstance.hasTable(tableName);
+    const result = await this.query(sql);
+    return result.length > 0;
+  }
+  /**
+   * Check if a column exists in a table
+   */
+  async hasColumn(tableName, columnName) {
+    const sql = this.dialectInstance.hasColumn(tableName, columnName);
+    const result = await this.query(sql);
+    return result.length > 0;
+  }
+  /**
+   * Alter a table
+   */
+  async alterTable(tableName, callback) {
+    const builder = new AlterTableBuilder(tableName);
+    callback(builder);
+    const definition = builder.getDefinition();
+    const statements = this.dialectInstance.alterTable(definition);
+    for (const sql of statements) {
+      await this.execute(sql);
+    }
+  }
+  /**
+   * Execute raw SQL
+   */
+  async raw(sql, params) {
+    await this.execute(sql, params);
+  }
+  /**
+   * Execute SQL statement
+   */
+  async execute(sql, params) {
+    if (this.adapter) {
+      await this.adapter.execute(sql, params);
+    } else {
+      console.log("SQL:", sql);
+      if (params && params.length > 0) {
+        console.log("Params:", params);
+      }
+    }
+  }
+  /**
+   * Execute SQL query
+   */
+  async query(sql) {
+    if (this.adapter) {
+      const result = await this.adapter.query(sql);
+      return result.rows;
+    }
+    return [];
+  }
+  /**
+   * Generate SQL without executing (for preview/dry-run)
+   */
+  generateCreateTableSQL(tableName, callback) {
+    const builder = new TableBuilder(tableName);
+    callback(builder);
+    return this.dialectInstance.createTable(builder.getDefinition());
+  }
+  /**
+   * Generate ALTER TABLE SQL without executing
+   */
+  generateAlterTableSQL(tableName, callback) {
+    const builder = new AlterTableBuilder(tableName);
+    callback(builder);
+    return this.dialectInstance.alterTable(builder.getDefinition());
+  }
+};
+var AlterTableBuilder = class {
+  tableName;
+  operations = [];
+  constructor(tableName) {
+    this.tableName = tableName;
+  }
+  /**
+   * Add a new column
+   */
+  addColumn(name, type, options) {
+    this.operations.push({
+      type: "addColumn",
+      column: {
+        name,
+        type,
+        nullable: true,
+        unsigned: false,
+        autoIncrement: false,
+        primary: false,
+        unique: false,
+        index: false,
+        first: false,
+        ...options
+      }
+    });
+    return this;
+  }
+  /**
+   * Drop a column
+   */
+  dropColumn(name) {
+    this.operations.push({ type: "dropColumn", name });
+    return this;
+  }
+  /**
+   * Rename a column
+   */
+  renameColumn(from, to) {
+    this.operations.push({ type: "renameColumn", from, to });
+    return this;
+  }
+  /**
+   * Modify a column
+   */
+  modifyColumn(name, type, options) {
+    this.operations.push({
+      type: "modifyColumn",
+      column: {
+        name,
+        type,
+        nullable: true,
+        unsigned: false,
+        autoIncrement: false,
+        primary: false,
+        unique: false,
+        index: false,
+        first: false,
+        ...options
+      }
+    });
+    return this;
+  }
+  /**
+   * Add an index
+   */
+  addIndex(columns, name) {
+    const columnArray = Array.isArray(columns) ? columns : [columns];
+    this.operations.push({
+      type: "addIndex",
+      index: {
+        name: name || `idx_${this.tableName}_${columnArray.join("_")}`,
+        columns: columnArray,
+        unique: false
+      }
+    });
+    return this;
+  }
+  /**
+   * Add a unique index
+   */
+  addUnique(columns, name) {
+    const columnArray = Array.isArray(columns) ? columns : [columns];
+    this.operations.push({
+      type: "addIndex",
+      index: {
+        name: name || `uniq_${this.tableName}_${columnArray.join("_")}`,
+        columns: columnArray,
+        unique: true
+      }
+    });
+    return this;
+  }
+  /**
+   * Drop an index
+   */
+  dropIndex(name) {
+    this.operations.push({ type: "dropIndex", name });
+    return this;
+  }
+  /**
+   * Add a foreign key
+   */
+  addForeign(column) {
+    return new AlterForeignKeyBuilder(this, column);
+  }
+  /**
+   * Add foreign key (internal)
+   */
+  addForeignKeyOperation(fk) {
+    this.operations.push({ type: "addForeignKey", foreignKey: fk });
+  }
+  /**
+   * Drop a foreign key
+   */
+  dropForeign(name) {
+    this.operations.push({ type: "dropForeignKey", name });
+    return this;
+  }
+  /**
+   * Add primary key
+   */
+  addPrimary(columns) {
+    const columnArray = Array.isArray(columns) ? columns : [columns];
+    this.operations.push({ type: "addPrimary", columns: columnArray });
+    return this;
+  }
+  /**
+   * Drop primary key
+   */
+  dropPrimary() {
+    this.operations.push({ type: "dropPrimary" });
+    return this;
+  }
+  /**
+   * Get the alter table definition
+   */
+  getDefinition() {
+    return {
+      tableName: this.tableName,
+      operations: [...this.operations]
+    };
+  }
+};
+var AlterForeignKeyBuilder = class {
+  builder;
+  fkDefinition;
+  constructor(builder, column) {
+    this.builder = builder;
+    this.fkDefinition = { column };
+  }
+  references(column) {
+    this.fkDefinition.referenceColumn = column;
+    return this;
+  }
+  on(tableName) {
+    this.fkDefinition.table = tableName;
+    this.apply();
+    return this;
+  }
+  onDelete(action) {
+    this.fkDefinition.onDelete = action;
+    this.apply();
+    return this;
+  }
+  onUpdate(action) {
+    this.fkDefinition.onUpdate = action;
+    this.apply();
+    return this;
+  }
+  name(name) {
+    this.fkDefinition.name = name;
+    this.apply();
+    return this;
+  }
+  apply() {
+    if (this.fkDefinition.column && this.fkDefinition.table && this.fkDefinition.referenceColumn) {
+      if (!this.fkDefinition.name) {
+        this.fkDefinition.name = `fk_${this.fkDefinition.column}_${this.fkDefinition.table}`;
+      }
+      this.builder.addForeignKeyOperation(this.fkDefinition);
+    }
+  }
+};
+
+// src/migrations/FileMigrationRunner.ts
+var FileMigrationRunner = class {
+  adapter;
+  loader;
+  lock;
+  schema;
+  options;
+  constructor(adapter, options) {
+    this.adapter = adapter;
+    this.options = {
+      directory: options.directory,
+      tableName: options.tableName ?? "db_migrations",
+      lockTableName: options.lockTableName ?? "db_migrations_lock",
+      lockTimeout: options.lockTimeout ?? 6e4,
+      validateChecksums: options.validateChecksums ?? true,
+      dialect: options.dialect,
+      logger: options.logger ?? console,
+      dryRun: options.dryRun ?? false
+    };
+    this.loader = new MigrationLoader(options.directory);
+    this.lock = new MigrationLock(adapter, {
+      tableName: this.options.lockTableName,
+      timeout: this.options.lockTimeout,
+      dialect: options.dialect
+    });
+    this.schema = new SchemaBuilder({
+      dialect: options.dialect,
+      adapter
+    });
+  }
+  /**
+   * Initialize migration tables
+   */
+  async initialize() {
+    if (this.options.dryRun) {
+      this.options.logger.info("DRY RUN: Would create migration tables");
+      return;
+    }
+    const tableName = this.options.tableName;
+    const hasTable = await this.schema.hasTable(tableName);
+    if (!hasTable) {
+      await this.schema.createTable(tableName, (table) => {
+        table.increments("id");
+        table.string("name", 255).notNull().unique();
+        table.integer("batch").notNull();
+        table.timestamp("executed_at").notNull().defaultNow();
+        table.integer("execution_time_ms").notNull();
+        table.string("checksum", 64).notNull();
+        table.index("batch");
+        table.index("executed_at");
+      });
+      this.options.logger.info(`Created migrations table: ${tableName}`);
+    }
+    await this.lock.initialize();
+  }
+  /**
+   * Run all pending migrations
+   */
+  async latest() {
+    await this.lock.initialize();
+    return this.lock.withLock(async () => {
+      await this.initialize();
+      const pending = await this.getPendingMigrations();
+      if (pending.length === 0) {
+        this.options.logger.info("No pending migrations");
+        return [];
+      }
+      const batch = await this.getNextBatch();
+      const executed = [];
+      this.options.logger.info(`Running ${pending.length} migrations (batch ${batch})`);
+      for (const migration of pending) {
+        await this.runMigration(migration, "up", batch);
+        executed.push(migration.name);
+      }
+      return executed;
+    });
+  }
+  /**
+   * Rollback the last batch of migrations
+   */
+  async rollback(steps = 1) {
+    await this.lock.initialize();
+    return this.lock.withLock(async () => {
+      await this.initialize();
+      const batches = await this.getLastBatches(steps);
+      if (batches.length === 0) {
+        this.options.logger.info("No migrations to rollback");
+        return [];
+      }
+      const rolledBack = [];
+      for (const batch of batches) {
+        this.options.logger.info(`Rolling back batch ${batch.batch}`);
+        const migrations = await this.loadMigrationsByName(
+          batch.migrations.map((m) => m.name).reverse()
+        );
+        for (const migration of migrations) {
+          await this.runMigration(migration, "down", batch.batch);
+          rolledBack.push(migration.name);
+        }
+      }
+      return rolledBack;
+    });
+  }
+  /**
+   * Reset all migrations
+   */
+  async reset() {
+    await this.lock.initialize();
+    return this.lock.withLock(async () => {
+      await this.initialize();
+      const executed = await this.getExecutedMigrations();
+      if (executed.length === 0) {
+        this.options.logger.info("No migrations to reset");
+        return [];
+      }
+      const rolledBack = [];
+      const migrations = await this.loadMigrationsByName(executed.map((m) => m.name).reverse());
+      for (const migration of migrations) {
+        const record = executed.find((e) => e.name === migration.name);
+        await this.runMigration(migration, "down", record.batch);
+        rolledBack.push(migration.name);
+      }
+      return rolledBack;
+    });
+  }
+  /**
+   * Reset and re-run all migrations
+   */
+  async fresh() {
+    await this.reset();
+    return this.latest();
+  }
+  /**
+   * Get migration status
+   */
+  async status() {
+    await this.initialize();
+    const allMigrations = await this.loader.getMigrationFiles();
+    const executed = await this.getExecutedMigrations();
+    const executedMap = new Map(executed.map((e) => [e.name, e]));
+    return allMigrations.map((file) => {
+      const record = executedMap.get(file.name);
+      return {
+        name: file.name,
+        batch: record?.batch ?? null,
+        executedAt: record?.executed_at ?? null,
+        pending: !record
+      };
+    });
+  }
+  /**
+   * Validate migrations
+   */
+  async validate() {
+    const errors = [];
+    try {
+      const migrations = await this.loader.loadAll();
+      const executed = await this.getExecutedMigrations();
+      for (const record of executed) {
+        const migration = migrations.find((m) => m.name === record.name);
+        if (!migration) {
+          errors.push(`Migration '${record.name}' exists in database but not in codebase`);
+          continue;
+        }
+        if (this.options.validateChecksums) {
+          const checksum = this.calculateChecksum(migration);
+          if (checksum !== record.checksum) {
+            errors.push(
+              `Checksum mismatch for migration '${record.name}'. The migration may have been modified.`
+            );
+          }
+        }
+      }
+    } catch (error2) {
+      errors.push(`Validation error: ${error2.message}`);
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Get pending migrations
+   */
+  async getPendingMigrations() {
+    const allMigrations = await this.loader.loadAll();
+    const executed = await this.getExecutedMigrations();
+    const executedNames = new Set(executed.map((e) => e.name));
+    return allMigrations.filter((m) => !executedNames.has(m.name));
+  }
+  /**
+   * Get executed migrations from database
+   */
+  async getExecutedMigrations() {
+    const result = await this.adapter.query(
+      `SELECT * FROM ${this.options.tableName} ORDER BY id ASC`
+    );
+    return result.rows;
+  }
+  /**
+   * Get the next batch number
+   */
+  async getNextBatch() {
+    const result = await this.adapter.query(
+      `SELECT MAX(batch) as max_batch FROM ${this.options.tableName}`
+    );
+    return (result.rows[0]?.max_batch ?? 0) + 1;
+  }
+  /**
+   * Get the last N batches
+   */
+  async getLastBatches(count) {
+    const result = await this.adapter.query(
+      `SELECT * FROM ${this.options.tableName} ORDER BY batch DESC, id DESC`
+    );
+    const batches = /* @__PURE__ */ new Map();
+    for (const record of result.rows) {
+      if (!batches.has(record.batch)) {
+        batches.set(record.batch, []);
+      }
+      batches.get(record.batch).push(record);
+    }
+    const batchNumbers = Array.from(batches.keys()).slice(0, count);
+    return batchNumbers.map((batch) => ({
+      batch,
+      migrations: batches.get(batch)
+    }));
+  }
+  /**
+   * Load migrations by name
+   */
+  async loadMigrationsByName(names) {
+    const allMigrations = await this.loader.loadAll();
+    const migrationMap = new Map(allMigrations.map((m) => [m.name, m]));
+    return names.map((name) => migrationMap.get(name)).filter((m) => m !== void 0);
+  }
+  /**
+   * Run a single migration
+   */
+  async runMigration(migration, direction, batch) {
+    const startTime = Date.now();
+    const action = direction === "up" ? "Running" : "Rolling back";
+    this.options.logger.info(`${action}: ${migration.name}`);
+    if (this.options.dryRun) {
+      this.options.logger.info(`DRY RUN: Would ${direction} ${migration.name}`);
+      return;
+    }
+    const transaction = migration.transactional ? await this.adapter.beginTransaction() : null;
+    try {
+      const schema = new SchemaBuilder({
+        dialect: this.options.dialect,
+        adapter: this.adapter
+      });
+      await migration[direction](schema);
+      const executionTime = Date.now() - startTime;
+      if (direction === "up") {
+        const checksum = this.calculateChecksum(migration);
+        await this.adapter.execute(
+          `INSERT INTO ${this.options.tableName}
+           (name, batch, executed_at, execution_time_ms, checksum)
+           VALUES (?, ?, NOW(), ?, ?)`,
+          [migration.name, batch, executionTime, checksum]
+        );
+      } else {
+        await this.adapter.execute(`DELETE FROM ${this.options.tableName} WHERE name = ?`, [
+          migration.name
+        ]);
+      }
+      if (transaction) {
+        await transaction.commit();
+      }
+      this.options.logger.info(
+        `${direction === "up" ? "Completed" : "Rolled back"}: ${migration.name} (${executionTime}ms)`
+      );
+    } catch (error2) {
+      if (transaction) {
+        await transaction.rollback();
+      }
+      throw new Error(
+        `Failed to ${direction} migration '${migration.name}': ${error2.message}`
+      );
+    }
+  }
+  /**
+   * Calculate migration checksum
+   */
+  calculateChecksum(migration) {
+    const content = `${migration.name}:${migration.up.toString()}:${migration.down.toString()}`;
+    return createHash("sha256").update(content).digest("hex");
+  }
+};
+
+// src/cli/utils.ts
+async function createAdapterFromConfig(config) {
+  const { dialect, host, port, user, password, database, ssl } = config.connection;
+  if (dialect === "mysql") {
+    try {
+      const { MySQLAdapter } = await import('@db-bridge/mysql');
+      const adapter = new MySQLAdapter();
+      await adapter.connect({
+        host,
+        port,
+        user,
+        password,
+        database
+      });
+      return adapter;
+    } catch (error2) {
+      if (error2.message.includes("Cannot find module")) {
+        throw new Error(
+          "MySQL adapter not found. Install it with: npm install @db-bridge/mysql mysql2"
+        );
+      }
+      throw error2;
+    }
+  }
+  if (dialect === "postgresql") {
+    try {
+      const { PostgreSQLAdapter } = await import('@db-bridge/postgresql');
+      const adapter = new PostgreSQLAdapter();
+      await adapter.connect({
+        host,
+        port,
+        user,
+        password,
+        database,
+        ssl
+      });
+      return adapter;
+    } catch (error2) {
+      if (error2.message.includes("Cannot find module")) {
+        throw new Error(
+          "PostgreSQL adapter not found. Install it with: npm install @db-bridge/postgresql pg"
+        );
+      }
+      throw error2;
+    }
+  }
+  throw new Error(`Unsupported dialect: ${dialect}`);
+}
+async function createRunnerFromConfig(options = {}) {
+  const config = await loadConfig();
+  const adapter = await createAdapterFromConfig(config);
+  const runner = new FileMigrationRunner(adapter, {
+    directory: resolve(process.cwd(), config.migrations?.directory || "./src/migrations"),
+    tableName: config.migrations?.tableName,
+    lockTableName: config.migrations?.lockTableName,
+    dialect: config.connection.dialect,
+    dryRun: options.dryRun
+  });
+  return { runner, adapter, config };
+}
+function formatTable(headers, rows) {
+  const widths = headers.map((h, i) => {
+    const maxRow = Math.max(...rows.map((r) => (r[i] || "").length));
+    return Math.max(h.length, maxRow);
+  });
+  const separator = "\u2500".repeat(widths.reduce((a, b) => a + b + 3, 1));
+  const headerRow = headers.map((h, i) => h.padEnd(widths[i])).join(" \u2502 ");
+  const dataRows = rows.map((row) => row.map((cell, i) => (cell || "").padEnd(widths[i])).join(" \u2502 ")).join("\n");
+  return `\u250C${separator}\u2510
+\u2502 ${headerRow} \u2502
+\u251C${separator}\u2524
+${dataRows ? dataRows.split("\n").map((r) => `\u2502 ${r} \u2502`).join("\n") : `\u2502${" ".repeat(separator.length)}\u2502`}
+\u2514${separator}\u2518`;
+}
+function success(message) {
+  console.log(`\u2713 ${message}`);
+}
+function error(message) {
+  console.error(`\u2717 ${message}`);
+}
+function info(message) {
+  console.log(`\u2139 ${message}`);
+}
+function warn(message) {
+  console.warn(`\u26A0 ${message}`);
+}
+
+// src/cli/commands/fresh.ts
+async function freshCommand(options = {}) {
+  let adapter;
+  try {
+    if (options.dryRun) {
+      info("DRY RUN MODE - No changes will be made");
+    } else {
+      warn("This will reset ALL migrations and re-run them!");
+    }
+    const { runner, adapter: a } = await createRunnerFromConfig(options);
+    adapter = a;
+    console.log("");
+    info("Resetting all migrations...");
+    const executed = await runner.fresh();
+    if (executed.length === 0) {
+      info("No migrations to run");
+    } else {
+      console.log("");
+      success(`Fresh migration complete - ran ${executed.length} migration(s):`);
+      for (const name of executed) {
+        console.log(`  - ${name}`);
+      }
+    }
+  } catch (error_) {
+    error(error_.message);
+    process.exit(1);
+  } finally {
+    if (adapter) {
+      await adapter.disconnect();
+    }
+  }
+}
+
+// src/cli/commands/latest.ts
+async function latestCommand(options = {}) {
+  let adapter;
+  try {
+    if (options.dryRun) {
+      info("DRY RUN MODE - No changes will be made");
+    }
+    const { runner, adapter: a } = await createRunnerFromConfig(options);
+    adapter = a;
+    const executed = await runner.latest();
+    if (executed.length === 0) {
+      info("Nothing to migrate");
+    } else {
+      console.log("");
+      success(`Ran ${executed.length} migration(s):`);
+      for (const name of executed) {
+        console.log(`  - ${name}`);
+      }
+    }
+  } catch (error_) {
+    error(error_.message);
+    process.exit(1);
+  } finally {
+    if (adapter) {
+      await adapter.disconnect();
+    }
+  }
+}
+async function makeCommand(name) {
+  try {
+    const config = await loadConfig();
+    const directory = resolve(process.cwd(), config.migrations?.directory || "./src/migrations");
+    if (!existsSync(directory)) {
+      await mkdir(directory, { recursive: true });
+      console.log(`Created migrations directory: ${directory}`);
+    }
+    const filename = MigrationLoader.generateFilename(name);
+    const filepath = resolve(directory, filename);
+    const migrationName = filename.replace(/\.(ts|js|mjs)$/, "");
+    const content = MigrationLoader.getMigrationTemplate(migrationName);
+    if (existsSync(filepath)) {
+      error(`Migration file already exists: ${filepath}`);
+      process.exit(1);
+    }
+    await writeFile(filepath, content, "utf8");
+    success(`Created migration: ${filename}`);
+    console.log(`  Path: ${filepath}`);
+  } catch (error_) {
+    error(error_.message);
+    process.exit(1);
+  }
+}
+var SeederLoader = class {
+  constructor(directory) {
+    this.directory = directory;
+  }
+  /**
+   * Load all seeder files from directory
+   */
+  async loadAll() {
+    const files = await readdir(this.directory);
+    const seederFiles = files.filter((f) => /\.(ts|js|mjs)$/.test(f) && !f.endsWith(".d.ts")).sort().map((f) => ({
+      name: this.getSeederName(f),
+      path: resolve(this.directory, f)
+    }));
+    return seederFiles;
+  }
+  /**
+   * Load a specific seeder by path
+   */
+  async load(seederPath) {
+    const fileUrl = pathToFileURL(seederPath).href;
+    const module = await import(fileUrl);
+    const seeder = module.default || module;
+    if (!seeder || typeof seeder.run !== "function") {
+      throw new Error(`Invalid seeder: ${seederPath} - must export a run() function`);
+    }
+    return seeder;
+  }
+  /**
+   * Get seeder name from filename
+   */
+  getSeederName(filename) {
+    return basename(filename).replace(/\.(ts|js|mjs)$/, "");
+  }
+  /**
+   * Generate a new seeder filename
+   */
+  static generateFilename(name) {
+    const snakeName = name.replaceAll(/([a-z])([A-Z])/g, "$1_$2").replaceAll(/[\s-]+/g, "_").toLowerCase();
+    return `${snakeName}_seeder.ts`;
+  }
+  /**
+   * Get seeder template
+   */
+  static getSeederTemplate(name) {
+    const className = name.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+    return `/**
+ * ${className} Seeder
+ */
+
+import type { Seeder, DatabaseAdapter } from '@db-bridge/core';
+
+export default {
+  async run(adapter: DatabaseAdapter): Promise<void> {
+    // Insert seed data
+    // await adapter.execute(\`
+    //   INSERT INTO users (name, email) VALUES
+    //   ('John Doe', 'john@example.com'),
+    //   ('Jane Doe', 'jane@example.com')
+    // \`);
+  },
+} satisfies Seeder;
+`;
+  }
+};
+
+// src/cli/commands/make-seeder.ts
+async function makeSeederCommand(name) {
+  try {
+    const config = await loadConfig();
+    const directory = resolve(process.cwd(), config.seeds?.directory || "./src/seeds");
+    if (!existsSync(directory)) {
+      await mkdir(directory, { recursive: true });
+      console.log(`Created seeds directory: ${directory}`);
+    }
+    const filename = SeederLoader.generateFilename(name);
+    const filepath = resolve(directory, filename);
+    const seederName = filename.replace(/\.(ts|js|mjs)$/, "");
+    const content = SeederLoader.getSeederTemplate(seederName);
+    if (existsSync(filepath)) {
+      error(`Seeder file already exists: ${filepath}`);
+      process.exit(1);
+    }
+    await writeFile(filepath, content, "utf8");
+    success(`Created seeder: ${filename}`);
+    console.log(`  Path: ${filepath}`);
+  } catch (error_) {
+    error(error_.message);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/reset.ts
+async function resetCommand(options = {}) {
+  let adapter;
+  try {
+    if (options.dryRun) {
+      info("DRY RUN MODE - No changes will be made");
+    } else {
+      warn("This will rollback ALL migrations!");
+    }
+    const { runner, adapter: a } = await createRunnerFromConfig(options);
+    adapter = a;
+    const rolledBack = await runner.reset();
+    if (rolledBack.length === 0) {
+      info("Nothing to reset");
+    } else {
+      console.log("");
+      success(`Reset ${rolledBack.length} migration(s):`);
+      for (const name of rolledBack) {
+        console.log(`  - ${name}`);
+      }
+    }
+  } catch (error_) {
+    error(error_.message);
+    process.exit(1);
+  } finally {
+    if (adapter) {
+      await adapter.disconnect();
+    }
+  }
+}
+
+// src/cli/commands/rollback.ts
+async function rollbackCommand(options = {}) {
+  let adapter;
+  try {
+    if (options.dryRun) {
+      info("DRY RUN MODE - No changes will be made");
+    }
+    const { runner, adapter: a } = await createRunnerFromConfig(options);
+    adapter = a;
+    const step = options.step ?? 1;
+    const rolledBack = await runner.rollback(step);
+    if (rolledBack.length === 0) {
+      info("Nothing to rollback");
+    } else {
+      console.log("");
+      success(`Rolled back ${rolledBack.length} migration(s):`);
+      for (const name of rolledBack) {
+        console.log(`  - ${name}`);
+      }
+    }
+  } catch (error_) {
+    error(error_.message);
+    process.exit(1);
+  } finally {
+    if (adapter) {
+      await adapter.disconnect();
+    }
+  }
+}
+
+// src/seeds/SeederRunner.ts
+var SeederRunner = class {
+  constructor(adapter, options) {
+    this.adapter = adapter;
+    this.options = options;
+    this.loader = new SeederLoader(options.directory);
+  }
+  loader;
+  options;
+  /**
+   * Run all seeders (or filtered by options)
+   */
+  async run() {
+    const files = await this.loader.loadAll();
+    const filteredFiles = this.filterSeeders(files);
+    const results = [];
+    for (const file of filteredFiles) {
+      const startTime = Date.now();
+      try {
+        const seeder = await this.loader.load(file.path);
+        await seeder.run(this.adapter);
+        results.push({
+          name: file.name,
+          success: true,
+          duration: Date.now() - startTime
+        });
+      } catch (error2) {
+        results.push({
+          name: file.name,
+          success: false,
+          error: error2.message,
+          duration: Date.now() - startTime
+        });
+        break;
+      }
+    }
+    return results;
+  }
+  /**
+   * Run a specific seeder by name
+   */
+  async runSeeder(name) {
+    const files = await this.loader.loadAll();
+    const file = files.find((f) => f.name === name || f.name === `${name}_seeder`);
+    if (!file) {
+      return {
+        name,
+        success: false,
+        error: `Seeder not found: ${name}`,
+        duration: 0
+      };
+    }
+    const startTime = Date.now();
+    try {
+      const seeder = await this.loader.load(file.path);
+      await seeder.run(this.adapter);
+      return {
+        name: file.name,
+        success: true,
+        duration: Date.now() - startTime
+      };
+    } catch (error2) {
+      return {
+        name: file.name,
+        success: false,
+        error: error2.message,
+        duration: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * Filter seeders based on options
+   */
+  filterSeeders(files) {
+    let filtered = files;
+    if (this.options.only && this.options.only.length > 0) {
+      filtered = filtered.filter(
+        (f) => this.options.only.some((name) => f.name === name || f.name === `${name}_seeder`)
+      );
+    }
+    if (this.options.except && this.options.except.length > 0) {
+      filtered = filtered.filter(
+        (f) => !this.options.except.some((name) => f.name === name || f.name === `${name}_seeder`)
+      );
+    }
+    return filtered;
+  }
+  /**
+   * List all available seeders
+   */
+  async list() {
+    return this.loader.loadAll();
+  }
+};
+
+// src/cli/commands/seed.ts
+async function seedCommand(options = {}) {
+  let adapter;
+  try {
+    const config = await loadConfig();
+    adapter = await createAdapterFromConfig(config);
+    const directory = resolve(process.cwd(), config.seeds?.directory || "./src/seeds");
+    const runner = new SeederRunner(adapter, { directory });
+    if (options.class) {
+      info(`Running seeder: ${options.class}`);
+      const result = await runner.runSeeder(options.class);
+      if (result.success) {
+        success(`Seeder completed: ${result.name} (${result.duration}ms)`);
+      } else {
+        error(`Seeder failed: ${result.error}`);
+        process.exit(1);
+      }
+    } else {
+      info("Running all seeders...");
+      console.log("");
+      const results = await runner.run();
+      if (results.length === 0) {
+        info("No seeders found");
+        return;
+      }
+      let hasErrors = false;
+      for (const result of results) {
+        if (result.success) {
+          success(`${result.name} (${result.duration}ms)`);
+        } else {
+          error(`${result.name}: ${result.error}`);
+          hasErrors = true;
+        }
+      }
+      console.log("");
+      if (hasErrors) {
+        error("Seeding completed with errors");
+        process.exit(1);
+      } else {
+        success(`Seeding complete - ran ${results.length} seeder(s)`);
+      }
+    }
+  } catch (error_) {
+    error(error_.message);
+    process.exit(1);
+  } finally {
+    if (adapter) {
+      await adapter.disconnect();
+    }
+  }
+}
+
+// src/cli/commands/status.ts
+async function statusCommand() {
+  let adapter;
+  try {
+    const { runner, adapter: a } = await createRunnerFromConfig();
+    adapter = a;
+    const status = await runner.status();
+    if (status.length === 0) {
+      console.log("No migrations found");
+      return;
+    }
+    const headers = ["Migration", "Batch", "Status", "Executed At"];
+    const rows = status.map((s) => [
+      s.name,
+      s.batch?.toString() || "-",
+      s.pending ? "Pending" : "Executed",
+      s.executedAt ? new Date(s.executedAt).toLocaleString() : "-"
+    ]);
+    console.log("");
+    console.log("Migration Status:");
+    console.log("");
+    console.log(formatTable(headers, rows));
+    console.log("");
+    const pendingCount = status.filter((s) => s.pending).length;
+    const executedCount = status.filter((s) => !s.pending).length;
+    console.log(
+      `Total: ${status.length} migrations (${executedCount} executed, ${pendingCount} pending)`
+    );
+  } catch (error_) {
+    error(error_.message);
+    process.exit(1);
+  } finally {
+    if (adapter) {
+      await adapter.disconnect();
+    }
+  }
+}
+
+// src/cli/commands/validate.ts
+async function validateCommand() {
+  let adapter;
+  try {
+    info("Validating migrations...");
+    console.log("");
+    const { runner, adapter: a } = await createRunnerFromConfig();
+    adapter = a;
+    const result = await runner.validate();
+    if (result.valid) {
+      success("All migrations are valid");
+    } else {
+      warn("Migration validation failed:");
+      console.log("");
+      for (const err of result.errors) {
+        error(`  ${err}`);
+      }
+      console.log("");
+      process.exit(1);
+    }
+  } catch (error_) {
+    error(error_.message);
+    process.exit(1);
+  } finally {
+    if (adapter) {
+      await adapter.disconnect();
+    }
+  }
+}
+
+// src/cli/index.ts
+var VERSION = "1.0.0";
+var HELP = `
+db-bridge - Database Migration & Seeding CLI
+
+Usage:
+  db-bridge <command> [options]
+
+Migration Commands:
+  migrate:make <name>     Create a new migration file
+  migrate:latest          Run all pending migrations
+  migrate:rollback        Rollback the last batch of migrations
+  migrate:status          Show migration status
+  migrate:reset           Rollback all migrations
+  migrate:fresh           Drop all tables and re-run migrations
+  migrate:validate        Validate migration checksums
+
+Seed Commands:
+  make:seeder <name>      Create a new seeder file
+  db:seed                 Run database seeders
+  db:seed --class=<name>  Run a specific seeder
+
+Options:
+  --help, -h              Show this help message
+  --version, -v           Show version number
+  --dry-run               Show what would be done without executing
+  --step=<n>              Number of batches to rollback (for rollback command)
+  --class=<name>          Specific seeder class to run (for db:seed)
+
+Examples:
+  db-bridge migrate:make create_users_table
+  db-bridge migrate:latest
+  db-bridge migrate:rollback --step=2
+  db-bridge make:seeder users
+  db-bridge db:seed
+  db-bridge db:seed --class=users
+`;
+async function main() {
+  const args = process.argv.slice(2);
+  let options = {};
+  let command = "";
+  let commandArgs = [];
+  try {
+    const { values, positionals } = parseArgs({
+      args,
+      options: {
+        help: { type: "boolean", short: "h" },
+        version: { type: "boolean", short: "v" },
+        "dry-run": { type: "boolean" },
+        step: { type: "string" },
+        class: { type: "string" }
+      },
+      allowPositionals: true
+    });
+    options = {
+      help: values.help,
+      version: values.version,
+      dryRun: values["dry-run"],
+      step: values.step ? parseInt(values.step, 10) : void 0,
+      class: values.class
+    };
+    command = positionals[0] || "";
+    commandArgs = positionals.slice(1);
+  } catch {
+    command = args[0] || "";
+    commandArgs = args.slice(1).filter((a) => !a.startsWith("-"));
+    options.help = args.includes("--help") || args.includes("-h");
+    options.version = args.includes("--version") || args.includes("-v");
+    options.dryRun = args.includes("--dry-run");
+    const stepArg = args.find((a) => a.startsWith("--step="));
+    if (stepArg) {
+      options.step = parseInt(stepArg.split("=")[1] || "1", 10);
+    }
+    const classArg = args.find((a) => a.startsWith("--class="));
+    if (classArg) {
+      options.class = classArg.split("=")[1];
+    }
+  }
+  if (options.help || command === "help") {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (options.version) {
+    console.log(`db-bridge v${VERSION}`);
+    process.exit(0);
+  }
+  if (!command) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  try {
+    switch (command) {
+      case "migrate:make": {
+        if (!commandArgs[0]) {
+          console.error("Error: Migration name is required");
+          console.log("Usage: db-bridge migrate:make <name>");
+          process.exit(1);
+        }
+        await makeCommand(commandArgs[0]);
+        break;
+      }
+      case "migrate:latest": {
+        await latestCommand({ dryRun: options.dryRun });
+        break;
+      }
+      case "migrate:rollback": {
+        await rollbackCommand({ dryRun: options.dryRun, step: options.step });
+        break;
+      }
+      case "migrate:status": {
+        await statusCommand();
+        break;
+      }
+      case "migrate:reset": {
+        await resetCommand({ dryRun: options.dryRun });
+        break;
+      }
+      case "migrate:fresh": {
+        await freshCommand({ dryRun: options.dryRun });
+        break;
+      }
+      case "migrate:validate": {
+        await validateCommand();
+        break;
+      }
+      case "make:seeder": {
+        if (!commandArgs[0]) {
+          console.error("Error: Seeder name is required");
+          console.log("Usage: db-bridge make:seeder <name>");
+          process.exit(1);
+        }
+        await makeSeederCommand(commandArgs[0]);
+        break;
+      }
+      case "db:seed": {
+        await seedCommand({ class: options.class });
+        break;
+      }
+      default: {
+        console.error(`Unknown command: ${command}`);
+        console.log('Run "db-bridge --help" for usage information.');
+        process.exit(1);
+      }
+    }
+  } catch (error2) {
+    console.error(`Error: ${error2.message}`);
+    process.exit(1);
+  }
+}
+main().catch((error2) => {
+  console.error("Fatal error:", error2);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map