@db-bridge/core 1.0.0 → 1.1.3

package/dist/index.js

@@ -1,6 +1,10 @@
 import { createHash, pbkdf2Sync, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
 import { constants, gzipSync, gunzipSync } from 'zlib';
 import { EventEmitter } from 'eventemitter3';
+import { readdir, readFile } from 'fs/promises';
+import { extname, join, basename, resolve } from 'path';
+import { pathToFileURL } from 'url';
+import { hostname } from 'os';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -351,7 +355,7 @@ async function withTimeout(promise, timeoutMs, message) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
 // src/utils/validation.ts
@@ -1657,7 +1661,7 @@ var HealthChecker = class {
       if (result.status === "healthy") {
         return;
       }
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
     }
     throw new Error(`Health check did not become healthy within ${maxWaitTime}ms`);
   }
@@ -2105,6 +2109,2533 @@ var MigrationRunner = class {
     };
   }
 };
+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 (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`Migration directory not found: ${this.directory}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * 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 (error) {
+      throw new Error(`Failed to load migration ${file.name}: ${error.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 sql2 = `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) {
+      sql2 += ` ${options.join(" ")}`;
+    }
+    return sql2;
+  }
+  /**
+   * 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 sql2 = `CREATE TABLE ${this.quoteIdentifier(definition.name)} (
+  ${parts.join(",\n  ")}
+)`;
+    const statements = [sql2];
+    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 (error) {
+        console.error("Error acquiring migration lock:", error);
+        throw error;
+      }
+    }
+    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 (error) {
+      console.error("Error releasing migration lock:", error);
+      throw error;
+    }
+  }
+  /**
+   * 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((resolve2) => setTimeout(resolve2, 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(sql2) {
+    this.definition.defaultRaw = sql2;
+    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 sql2 = this.dialectInstance.createTable(definition);
+    await this.execute(sql2);
+    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 exists2 = await this.hasTable(tableName);
+    if (!exists2) {
+      await this.createTable(tableName, callback);
+    }
+  }
+  /**
+   * Drop a table
+   */
+  async dropTable(tableName) {
+    const sql2 = this.dialectInstance.dropTable(tableName);
+    await this.execute(sql2);
+  }
+  /**
+   * Drop a table if it exists
+   */
+  async dropTableIfExists(tableName) {
+    const sql2 = this.dialectInstance.dropTableIfExists(tableName);
+    await this.execute(sql2);
+  }
+  /**
+   * Rename a table
+   */
+  async renameTable(from, to) {
+    const sql2 = this.dialectInstance.renameTable(from, to);
+    await this.execute(sql2);
+  }
+  /**
+   * Check if a table exists
+   */
+  async hasTable(tableName) {
+    const sql2 = this.dialectInstance.hasTable(tableName);
+    const result = await this.query(sql2);
+    return result.length > 0;
+  }
+  /**
+   * Check if a column exists in a table
+   */
+  async hasColumn(tableName, columnName) {
+    const sql2 = this.dialectInstance.hasColumn(tableName, columnName);
+    const result = await this.query(sql2);
+    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 sql2 of statements) {
+      await this.execute(sql2);
+    }
+  }
+  /**
+   * Execute raw SQL
+   */
+  async raw(sql2, params) {
+    await this.execute(sql2, params);
+  }
+  /**
+   * Execute SQL statement
+   */
+  async execute(sql2, params) {
+    if (this.adapter) {
+      await this.adapter.execute(sql2, params);
+    } else {
+      console.log("SQL:", sql2);
+      if (params && params.length > 0) {
+        console.log("Params:", params);
+      }
+    }
+  }
+  /**
+   * Execute SQL query
+   */
+  async query(sql2) {
+    if (this.adapter) {
+      const result = await this.adapter.query(sql2);
+      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 (error) {
+      errors.push(`Validation error: ${error.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(count2) {
+    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, count2);
+    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 (error) {
+      if (transaction) {
+        await transaction.rollback();
+      }
+      throw new Error(
+        `Failed to ${direction} migration '${migration.name}': ${error.message}`
+      );
+    }
+  }
+  /**
+   * Calculate migration checksum
+   */
+  calculateChecksum(migration) {
+    const content = `${migration.name}:${migration.up.toString()}:${migration.down.toString()}`;
+    return createHash("sha256").update(content).digest("hex");
+  }
+};
+
+// src/migrations/ExpandContract.ts
+var ExpandContractHelper = class {
+  constructor(adapter, schema) {
+    this.adapter = adapter;
+    this.schema = schema;
+  }
+  /**
+   * Rename a column using expand/contract pattern
+   * Expand: Add new column
+   * Migrate: Copy data from old to new
+   * Contract: Drop old column
+   */
+  async renameColumn(table, oldColumn, newColumn, phase) {
+    switch (phase) {
+      case "expand": {
+        await this.schema.alterTable(table, (t) => {
+          t.addColumn(newColumn, "text");
+        });
+        break;
+      }
+      case "migrate": {
+        await this.adapter.execute(
+          `UPDATE ${table} SET ${newColumn} = ${oldColumn} WHERE ${newColumn} IS NULL`
+        );
+        break;
+      }
+      case "contract": {
+        await this.schema.alterTable(table, (t) => {
+          t.dropColumn(oldColumn);
+        });
+        break;
+      }
+    }
+  }
+  /**
+   * Change column type using expand/contract pattern
+   */
+  async changeColumnType(table, column, newType, transform, phase) {
+    const tempColumn = `${column}_new`;
+    switch (phase) {
+      case "expand": {
+        await this.adapter.execute(`ALTER TABLE ${table} ADD COLUMN ${tempColumn} ${newType}`);
+        break;
+      }
+      case "migrate": {
+        await this.adapter.execute(`UPDATE ${table} SET ${tempColumn} = ${transform}`);
+        break;
+      }
+      case "contract": {
+        await this.adapter.execute(`ALTER TABLE ${table} DROP COLUMN ${column}`);
+        await this.adapter.execute(`ALTER TABLE ${table} RENAME COLUMN ${tempColumn} TO ${column}`);
+        break;
+      }
+    }
+  }
+  /**
+   * Split a table into two tables using expand/contract
+   */
+  async splitTable(sourceTable, newTable, columnsToMove, foreignKeyColumn, phase) {
+    switch (phase) {
+      case "expand": {
+        await this.schema.createTable(newTable, (t) => {
+          t.increments("id");
+          t.integer(foreignKeyColumn).notNull();
+        });
+        break;
+      }
+      case "migrate": {
+        const cols = columnsToMove.join(", ");
+        await this.adapter.execute(
+          `INSERT INTO ${newTable} (${foreignKeyColumn}, ${cols})
+           SELECT id, ${cols} FROM ${sourceTable}`
+        );
+        break;
+      }
+      case "contract": {
+        for (const col of columnsToMove) {
+          await this.schema.alterTable(sourceTable, (t) => {
+            t.dropColumn(col);
+          });
+        }
+        break;
+      }
+    }
+  }
+  /**
+   * Merge two tables into one using expand/contract
+   */
+  async mergeTables(targetTable, sourceTable, columnsToMerge, joinColumn, phase) {
+    switch (phase) {
+      case "expand": {
+        for (const col of columnsToMerge) {
+          await this.schema.alterTable(targetTable, (t) => {
+            t.addColumn(col, "text");
+          });
+        }
+        break;
+      }
+      case "migrate": {
+        const setClauses = columnsToMerge.map((col) => `${targetTable}.${col} = ${sourceTable}.${col}`).join(", ");
+        await this.adapter.execute(
+          `UPDATE ${targetTable}
+           SET ${setClauses}
+           FROM ${sourceTable}
+           WHERE ${targetTable}.id = ${sourceTable}.${joinColumn}`
+        );
+        break;
+      }
+      case "contract": {
+        await this.schema.dropTable(sourceTable);
+        break;
+      }
+    }
+  }
+  /**
+   * Add NOT NULL constraint safely
+   */
+  async addNotNullConstraint(table, column, defaultValue, phase) {
+    switch (phase) {
+      case "expand": {
+        await this.adapter.execute(
+          `UPDATE ${table} SET ${column} = ${defaultValue} WHERE ${column} IS NULL`
+        );
+        break;
+      }
+      case "migrate": {
+        const result = await this.adapter.query(
+          `SELECT COUNT(*) as count FROM ${table} WHERE ${column} IS NULL`
+        );
+        if (result.rows[0]?.count && result.rows[0].count > 0) {
+          throw new Error(
+            `Cannot add NOT NULL: ${result.rows[0].count} rows still have NULL values`
+          );
+        }
+        break;
+      }
+      case "contract": {
+        await this.schema.alterTable(table, (t) => {
+          t.modifyColumn(column, "text", { nullable: false });
+        });
+        break;
+      }
+    }
+  }
+};
+function createExpandContractHelper(adapter, schema) {
+  return new ExpandContractHelper(adapter, schema);
+}
+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/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 (error) {
+        results.push({
+          name: file.name,
+          success: false,
+          error: error.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 (error) {
+      return {
+        name: file.name,
+        success: false,
+        error: error.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();
+  }
+};
 var PerformanceMonitor = class extends EventEmitter {
   traces = /* @__PURE__ */ new Map();
   slowQueries = [];
@@ -4188,13 +6719,13 @@ var SQLDialect = class {
       const fromClause = components.fromAlias ? `${this.escapeIdentifier(components.from)} AS ${this.escapeIdentifier(components.fromAlias)}` : this.escapeIdentifier(components.from);
       parts.push(fromClause);
     }
-    for (const join of components.joins) {
-      parts.push(`${join.type} JOIN ${this.escapeIdentifier(join.table)}`);
-      if (join.alias) {
-        parts.push(`AS ${this.escapeIdentifier(join.alias)}`);
+    for (const join2 of components.joins) {
+      parts.push(`${join2.type} JOIN ${this.escapeIdentifier(join2.table)}`);
+      if (join2.alias) {
+        parts.push(`AS ${this.escapeIdentifier(join2.alias)}`);
       }
-      parts.push(`ON ${join.condition}`);
-      bindings.push(...join.bindings);
+      parts.push(`ON ${join2.condition}`);
+      bindings.push(...join2.bindings);
     }
     if (components.where.length > 0) {
       parts.push("WHERE");
@@ -4341,7 +6872,7 @@ var SQLDialect = class {
 };
 
 // src/dialect/mysql-dialect.ts
-var MySQLDialect = class extends SQLDialect {
+var MySQLDialect2 = class extends SQLDialect {
   name = "mysql";
   config = {
     identifierQuote: "`",
@@ -4453,7 +6984,7 @@ var MySQLDialect = class extends SQLDialect {
 };
 
 // src/dialect/postgresql-dialect.ts
-var PostgreSQLDialect = class extends SQLDialect {
+var PostgreSQLDialect2 = class extends SQLDialect {
   name = "postgresql";
   config = {
     identifierQuote: '"',
@@ -4607,10 +7138,10 @@ var DialectFactory = class {
     const normalizedType = this.normalizeType(type);
     switch (normalizedType) {
       case "mysql": {
-        return new MySQLDialect();
+        return new MySQLDialect2();
       }
       case "postgresql": {
-        return new PostgreSQLDialect();
+        return new PostgreSQLDialect2();
       }
       default: {
         throw new Error(`Unsupported database type: ${type}`);
@@ -6316,7 +8847,7 @@ function calculateDelay(attempt, baseDelay, maxDelay, multiplier) {
   return Math.floor(cappedDelay + jitter);
 }
 function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function createRetryMiddleware(options = {}) {
   const {
@@ -7164,12 +9695,12 @@ var DBBridge2 = class _DBBridge {
       const dbType = this.config.type;
       switch (dbType) {
         case "mysql": {
-          this._dialect = new MySQLDialect();
+          this._dialect = new MySQLDialect2();
           break;
         }
         case "postgresql":
         case "postgres": {
-          this._dialect = new PostgreSQLDialect();
+          this._dialect = new PostgreSQLDialect2();
           break;
         }
         case "redis": {
@@ -7793,6 +10324,6 @@ var DBBridge3 = class _DBBridge {
   }
 };
 
-export { ANALYSIS_DEFAULTS, BaseAdapter, BaseQueryBuilder, BaseTransaction, CACHE_DEFAULTS, CONNECTION_DEFAULTS, CRYPTO_DEFAULTS, CacheAPI, CacheError, CacheKeyGenerator, CacheManager, CacheableQuery, CachedAdapter, CachedDBBridge, DBBridge as Client, ConnectionError, CryptoAlgorithms, CryptoProvider, DBBridge2 as DBBridge, DBBridgeError, DBBridge3 as DBBridgeFactory, DEFAULT_POOL_CONFIG, DEFAULT_TIMEOUTS, DURATION_BUCKETS, DatabaseError, DefaultCacheStrategy, DeleteBuilder, DialectFactory, HEALTH_DEFAULTS, HealthChecker, ISOLATION_LEVELS, InsertBuilder, IsolationLevel, LOGGING_DEFAULTS, MetricsCollector, MiddlewareChain, MigrationRunner, ModularCacheManager, ModularPerformanceMonitor, MySQLDialect, NotImplementedError, POOL_DEFAULTS, POOL_DEFAULTS_LEGACY, PerformanceMonitor, PoolExhaustedError, PostgreSQLDialect, QUERY_DEFAULTS, QueryContext, QueryError, QueryTimeoutError, RETRY_DEFAULTS, SIZE_UNITS, SQLDialect, SelectBuilder, SmartCacheStrategy, TIME_UNITS, TimeoutError, TransactionError, UpdateBuilder, ValidationError, WhereBuilder, avg, cacheKey, chunk, composeMiddleware, compress, count, createAdapter, createCacheInvalidationMiddleware, createCacheKeyPattern, createCacheMiddleware, createCachedAdapter, createCircuitBreakerMiddleware, createDeadlineMiddleware, createLoggingMiddleware, createMetricsMiddleware, createModularQueryBuilder, createQueryState, createRetryMiddleware, createTimeoutMiddleware, crypto, cursorPaginate, decompress, encryptRow, exists, generateCacheKey, generateUUID, getCompressionRatio, isCompressed, isDeleteResult, isInsertResult, isSelectResult, isUpdateResult, max, min, paginate, parseCacheKey, processDataForEncryption, processResultsForDecryption, registerAdapterFactory, retry, sanitizeCacheKey, shouldCompress, sql, sum, validateColumnName, validateConnectionConfig, validateSQL, validateTableName, whereBetweenDates, whereDate, whereDay, whereLastDays, whereMonth, whereToday, whereYear, whereYesterday, withTimeout };
+export { ANALYSIS_DEFAULTS, AlterTableBuilder, BaseAdapter, BaseQueryBuilder, BaseTransaction, CACHE_DEFAULTS, CONNECTION_DEFAULTS, CRYPTO_DEFAULTS, CacheAPI, CacheError, CacheKeyGenerator, CacheManager, CacheableQuery, CachedAdapter, CachedDBBridge, DBBridge as Client, ColumnBuilder, ConnectionError, CryptoAlgorithms, CryptoProvider, DBBridge2 as DBBridge, DBBridgeError, DBBridge3 as DBBridgeFactory, DEFAULT_POOL_CONFIG, DEFAULT_TIMEOUTS, DURATION_BUCKETS, DatabaseError, DefaultCacheStrategy, DeleteBuilder, DialectFactory, ExpandContractHelper, FileMigrationRunner, ForeignKeyBuilder, ForeignKeyChain, HEALTH_DEFAULTS, HealthChecker, ISOLATION_LEVELS, InsertBuilder, IsolationLevel, LOGGING_DEFAULTS, MetricsCollector, MiddlewareChain, MigrationLoader, MigrationLock, MigrationRunner, ModularCacheManager, ModularPerformanceMonitor, MySQLDialect2 as MySQLDialect, NotImplementedError, POOL_DEFAULTS, POOL_DEFAULTS_LEGACY, PerformanceMonitor, PoolExhaustedError, PostgreSQLDialect2 as PostgreSQLDialect, QUERY_DEFAULTS, QueryContext, QueryError, QueryTimeoutError, RETRY_DEFAULTS, SIZE_UNITS, SQLDialect, SchemaBuilder, MySQLDialect as SchemaMySQLDialect, PostgreSQLDialect as SchemaPostgreSQLDialect, SeederLoader, SeederRunner, SelectBuilder, SmartCacheStrategy, TIME_UNITS, TableBuilder, TimeoutError, TransactionError, UpdateBuilder, ValidationError, WhereBuilder, avg, cacheKey, chunk, composeMiddleware, compress, count, createAdapter, createCacheInvalidationMiddleware, createCacheKeyPattern, createCacheMiddleware, createCachedAdapter, createCircuitBreakerMiddleware, createDeadlineMiddleware, createExpandContractHelper, createLoggingMiddleware, createMetricsMiddleware, createModularQueryBuilder, createQueryState, createRetryMiddleware, createTimeoutMiddleware, crypto, cursorPaginate, decompress, encryptRow, exists, generateCacheKey, generateUUID, getCompressionRatio, isCompressed, isDeleteResult, isInsertResult, isSelectResult, isUpdateResult, max, min, paginate, parseCacheKey, processDataForEncryption, processResultsForDecryption, registerAdapterFactory, retry, sanitizeCacheKey, shouldCompress, sql, sum, validateColumnName, validateConnectionConfig, validateSQL, validateTableName, whereBetweenDates, whereDate, whereDay, whereLastDays, whereMonth, whereToday, whereYear, whereYesterday, withTimeout };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map