sqlmorpheus 0.1.8 → 0.1.10

package/dist/index.mjs

@@ -40,31 +40,36 @@ function getTableInfoFromMetadata(metadata) {
 // src/lib/TableStructureGenerator.ts
 var TableStructureGenerator = class {
   dialect;
-  tables = {};
-  constructor(dbContext, dialect) {
+  dbInstructions;
+  constructor(dbInstructions, dialect) {
     this.dialect = dialect;
-    if (dbContext.tables.length) {
+    this.dbInstructions = dbInstructions;
+  }
+  generateTableStructure() {
+    if (this.dbInstructions.tables.length) {
       const tableObjects = {};
-      for (const table of dbContext.tables) {
+      for (const table of this.dbInstructions.tables) {
         tableObjects[table.name] = { columns: new table(), tableInfo: getTableInfo(table) };
       }
-      this.getExpectedStructure(tableObjects);
+      return this.getExpectedStructure(tableObjects);
     } else {
-      const tableObjects = dbContext.tables;
-      this.getExpectedStructure(tableObjects);
+      const tableObjects = this.dbInstructions.tables;
+      return this.getExpectedStructure(tableObjects);
     }
   }
   getExpectedStructure(tableObjects) {
+    const tables = {};
     for (const tableName in tableObjects) {
       const obj = tableObjects[tableName];
       const tableInfo = obj.tableInfo;
-      this.tables[tableName] = {
+      tables[tableName] = {
         table: tableName,
         primaryKey: tableInfo?.primaryKey,
         columns: this.getColumns(obj.columns, tableInfo?.primaryKey),
         foreignKeys: tableInfo?.foreignKeys
       };
     }
+    return tables;
   }
   getColumns(obj, primaryKey) {
     const columns = [];
@@ -108,38 +113,32 @@ var TableStructureGenerator = class {
 
 // src/lib/exceptions/NotAllowedException.ts
 var NotAllowedException = class extends Error {
-  constructor(version, tableName, type) {
-    const information = `You have to enable "${type}" for version "${version}" and table "${tableName}"`;
-    switch (type) {
-      case "continueWithoutRollback":
-        super(`Some changes can not be rolled back automatically. ${information}`);
-        break;
-      case "dropColumn":
-        super(`Not allowed to drop column. ${information}`);
-        break;
-      case "dropTable":
-        super(`Not allowed to drop table. ${information}`);
-        break;
-      case "recreateTable":
-        super(`Not allowed to recreate table. ${information}`);
-        break;
-      case "alterForeignKey":
-        super(`Not allowed to alter existing foreign key. ${information}`);
-        break;
-      case "alterPrimaryKey":
-        super(`Not allowed to alter primary key. ${information}`);
-        break;
-      case "removeForeignKey":
-        super(`Not allowed to remove existing foreign key. ${information}`);
-        break;
+  constructor(entries) {
+    let message = "Some destructive changes need to be confirmed. In preMigrations() run:";
+    for (const entry of entries) {
+      message += `
+migrations.allowMigration(${entry.version}, "${entry.tableName}", "${entry.type}");`;
     }
+    super(`${message}
+
+`);
   }
 };
 
 // src/lib/typings/Migrations.ts
 var Migrations = class {
-  migrationData = {};
+  toVersion = 0;
   alwaysAllowed = {};
+  fromVersion = 0;
+  migrationData = {};
+  notAllowedChanges = [];
+  reset(dbInstructions, fromVersion) {
+    this.fromVersion = fromVersion;
+    this.migrationData = {};
+    this.toVersion = dbInstructions.version;
+    this.alwaysAllowed = dbInstructions.alwaysAllowedMigrations ?? {};
+    this.notAllowedChanges = [];
+  }
   getEntry(table) {
     const tableName = this.getTableName(table);
     if (!this.migrationData.hasOwnProperty(tableName)) {
@@ -154,30 +153,40 @@ var Migrations = class {
   getTableName(table) {
     return typeof table == "string" ? table : table.name;
   }
-  alwaysAllow(...allowedMigrations) {
-    for (const key of allowedMigrations) {
-      this.alwaysAllowed[key] = true;
+  verifyMigration(tableName, type) {
+    if (!this.migrationData[tableName]?.allowedMigrations[type] && !this.alwaysAllowed[type])
+      this.notAllowedChanges.push({ version: this.toVersion, tableName, type });
+  }
+  checkIfAllowed(throwIfNotAllowed) {
+    if (!this.notAllowedChanges.length)
+      return true;
+    const exception = new NotAllowedException(this.notAllowedChanges);
+    if (throwIfNotAllowed)
+      throw exception;
+    else {
+      console.error(exception.message);
+      return false;
     }
   }
   allowMigration(version, table, ...allowedMigrations) {
+    if (version < this.fromVersion || version > this.toVersion)
+      return;
     const entry = this.getEntry(table);
-    if (!entry.allowedMigrations.hasOwnProperty(version))
-      entry.allowedMigrations[version] = {};
     for (const key of allowedMigrations) {
-      this.alwaysAllowed[key] = true;
+      entry.allowedMigrations[key] = true;
     }
   }
-  throwIfNotAllowed(version, tableName, type) {
-    if (!(this.migrationData[tableName]?.allowedMigrations[version] ?? this.alwaysAllowed)[type])
-      throw new NotAllowedException(version, tableName, type);
-  }
-  renameTable(oldTableName, newTable) {
+  renameTable(version, oldTableName, newTable) {
+    if (version < this.fromVersion || version > this.toVersion)
+      return;
     const entry = this.getEntry(newTable);
     entry.recreate = true;
     if (!entry.oldTableName)
       entry.oldTableName = oldTableName;
   }
-  renameColumn(table, oldColumn, newColumn) {
+  renameColumn(version, table, oldColumn, newColumn) {
+    if (version < this.fromVersion || version > this.toVersion)
+      return;
     const entry = this.getEntry(table);
     const existingColumnEntry = entry.renamedColumns.find((entry2) => entry2[entry2.length - 1] == oldColumn);
     if (existingColumnEntry)
@@ -185,10 +194,15 @@ var Migrations = class {
     else
       entry.renamedColumns.push([oldColumn, newColumn]);
   }
-  recreateTable(table) {
+  recreateTableImp(table) {
     const entry = this.getEntry(table);
     entry.recreate = true;
   }
+  recreateTable(version, table) {
+    if (version < this.fromVersion || version > this.toVersion)
+      return;
+    this.recreateTableImp(table);
+  }
   getMigrationData() {
     return this.migrationData;
   }
@@ -203,7 +217,7 @@ var Migrations = class {
     }
   }
   getUpdatedColumnName(tableName, oldColumnName) {
-    const columnNames = this.migrationData[tableName].renamedColumns.find((columns) => columns[0] == oldColumnName);
+    const columnNames = this.migrationData[tableName]?.renamedColumns.find((columns) => columns[0] == oldColumnName);
     return columnNames ? columnNames[columnNames.length - 1] : oldColumnName;
   }
   willBeRecreated(tableName) {
@@ -211,827 +225,836 @@ var Migrations = class {
   }
 };
 
-// src/lib/MigrationHistoryManager.ts
-import { existsSync, mkdirSync, writeFileSync } from "fs";
-import { readFileSync } from "fs";
-var FILENAME_UP_PREFIX = "up_to_";
-var FILENAME_DOWN_PREFIX = "down_to_";
-var MigrationHistoryManager = class {
-  configPath;
-  migrationsPath;
-  constructor(configPath) {
-    this.configPath = configPath;
-    this.migrationsPath = `${configPath}/migrations`;
-    mkdirSync(this.configPath, { recursive: true });
-    mkdirSync(this.migrationsPath, { recursive: true });
+// src/lib/MigrationManager.ts
+var MigrationManager = class {
+  migrations = new Migrations();
+  newTables = {};
+  existingTables = [];
+  dialect;
+  constructor(dialect) {
+    this.dialect = dialect;
   }
   /**
-   * Creates migration history files for upgrading and downgrading database schemas.
+   * Generates the SQL changes required to migrate a database from its current version
+   * to the target version defined in the database instructions. Handles the creation
+   * and deletion of tables, migration of foreign keys and columns, renaming of columns,
+   * and recreating tables, along with executing any pre- and post-migration custom logic.
    *
-   * @param fromVersion - The current version number of the database.
-   * @param toVersion - The target version number for the migration.
-   * @param changes - An object containing the SQL changes for upgrading (`changes.up`) and downgrading (`changes.down`).
-   * @param overwriteExisting - A flag that determines if existing migration files should be overwritten. Defaults to `false`.
+   * @return A promise that resolves to an object containing the SQL
+   * changes for the migration (`up` and `down` changes) or null if no migration is required.
+   * Throws an error in scenarios such as attempting to migrate to a lower version
+   * or an invalid starting version.
    */
-  createMigrationHistory(fromVersion, toVersion, changes, overwriteExisting) {
-    const upPath = `${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion}.sql`;
-    const downPath = `${this.migrationsPath}/${FILENAME_DOWN_PREFIX}${fromVersion}.sql`;
-    if (existsSync(upPath) && !overwriteExisting)
-      throw new Error(`Migration ${upPath} already exists!`);
-    else if (existsSync(downPath) && !overwriteExisting)
-      throw new Error(`Migration ${downPath} already exists!`);
-    Logger.log(`Save migrations to ${this.migrationsPath}`);
-    writeFileSync(`${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion}.sql`, `-- From: Version ${fromVersion}
--- To:   Version ${toVersion}
-${changes.up}`, { encoding: "utf-8" });
-    writeFileSync(`${this.migrationsPath}/${FILENAME_DOWN_PREFIX}${fromVersion}.sql`, `-- From: Version ${toVersion}
--- To:   Version ${fromVersion}
-${changes.down}`, { encoding: "utf-8" });
+  async generateSqlChanges(dbInstructions) {
+    const fromVersion = await this.dialect.getVersion();
+    const toVersion = dbInstructions.version;
+    if (toVersion <= 0)
+      throw new Error("Cannot migrate to version 0 or lower");
+    if (fromVersion == toVersion) {
+      Logger.log("Version has not changed. No migrations needed.");
+      return null;
+    }
+    if (fromVersion > toVersion)
+      throw new Error(`You cannot create new migrations with a lower version (from ${fromVersion} to ${toVersion})`);
+    const foreignKeyOffQuery = this.dialect.changeForeignKeysState(false);
+    const changes = {
+      up: foreignKeyOffQuery,
+      down: foreignKeyOffQuery
+    };
+    this.migrations.reset(dbInstructions, fromVersion);
+    const preSQL = dbInstructions.preMigration?.(
+      this.migrations,
+      fromVersion,
+      toVersion
+    );
+    if (preSQL) {
+      changes.up += `
+
+-- Custom SQL from preMigration()
+${preSQL.up}`;
+      changes.down += `
+
+-- Custom SQL from preMigration()
+${preSQL.down}`;
+    }
+    const tableStructureGenerator = new TableStructureGenerator(dbInstructions, this.dialect);
+    this.newTables = tableStructureGenerator.generateTableStructure();
+    if (fromVersion == 0) {
+      Logger.log(`Creating initial migration to version ${dbInstructions.version}`);
+      const initialChanges = await this.createAndDropTables();
+      changes.up += initialChanges.up;
+      changes.down += initialChanges.down;
+    } else {
+      Logger.log(`Creating migration SQL from version ${fromVersion} to ${toVersion}`);
+      this.existingTables = await this.dialect.getTableNames();
+      [
+        await this.createAndDropTables(),
+        await this.migrateForeignKeys(),
+        await this.migrateColumns(),
+        this.renameColumns(),
+        await this.recreateTables()
+      ].forEach((entry) => {
+        changes.up += entry.up;
+        changes.down += entry.down;
+      });
+    }
+    const postSql = dbInstructions.postMigration?.(fromVersion, toVersion);
+    if (postSql) {
+      changes.up += `
+
+-- Custom SQL from postMigration()
+${postSql.up}`;
+      changes.down += `
+
+-- Custom SQL from postMigration()
+${postSql.down}`;
+    }
+    const foreignKeyOnQuery = this.dialect.changeForeignKeysState(true);
+    changes.up += `
+
+${foreignKeyOnQuery}`;
+    changes.down += `
+
+${foreignKeyOnQuery}`;
+    if (!this.migrations.checkIfAllowed(dbInstructions.throwIfNotAllowed)) {
+      return null;
+    }
+    return {
+      fromVersion,
+      toVersion,
+      changes
+    };
   }
   /**
-   * Retrieves the SQL migration script for upgrading to the specified version.
-   * If no version is provided, it retrieves the migration script for the latest version in the history.
+   * Generates SQL change statements for creating and dropping tables based on the current table structure
+   * and existing table configurations in the database. The `up` changes include SQL statements for creating
+   * new tables, while the `down` changes include SQL statements for dropping the corresponding tables or
+   * recreating them if necessary.
    *
-   * @param toVersion - The version of the migration script to retrieve. If not specified, the latest version is used.
-   * @return The content of the SQL migration script as a string.
+   * @return {Promise<SqlChanges>} A promise that resolves to an object containing `up` and `down` SQL
+   * change statements for migrating the database schema.
    */
-  getUpMigration(toVersion) {
-    return readFileSync(`${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion}.sql`, { encoding: "utf-8" });
+  async createAndDropTables() {
+    let changes = {
+      up: "\n\n-- Create tables\n",
+      down: "\n\n-- Create tables\n"
+    };
+    for (const tableName in this.newTables) {
+      if (this.tableDoesNotExists(tableName)) {
+        const structure = this.newTables[tableName];
+        changes.up += `${this.createTableSql(tableName, structure.columns, structure.foreignKeys)}
+`;
+        changes.down += `${this.dialect.dropTable(tableName)}
+`;
+      }
+    }
+    for (const tableName of this.existingTables) {
+      if (!this.newTables[tableName]) {
+        this.migrations.verifyMigration(tableName, "dropTable");
+        if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
+          this.migrations.verifyMigration(tableName, "continueWithoutRollback");
+        changes.up += `${this.dialect.dropTable(tableName)}
+`;
+        changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(tableName, await this.dialect.getColumnInformation(tableName), await this.dialect.getForeignKeys(tableName)) : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
+      }
+    }
+    return changes;
   }
   /**
-   * Retrieves the SQL migration script for downgrading to the specified version.
+   * Generates an SQL string to create a table with the specified schema.
    *
-   * @param version - The version number of the migration to retrieve.
-   * @return The SQL script for the down migration.
+   * @param tableName - The name of the table to be created.
+   * @param columns - An array of objects defining the columns of the table, including their names, types
+   * default values, and whether they are primary keys.
+   * @param foreignKeys - An optional array of objects defining the foreign key constraints for the table,
+   * including the source column, target table, target column, action on update, and action on delete.
+   * @return The complete SQL string to create the table with the specified structure and constraints.
    */
-  getDownMigration(version) {
-    return readFileSync(`${this.migrationsPath}/${FILENAME_DOWN_PREFIX}${version}.sql`, { encoding: "utf-8" });
-  }
-};
-
-// src/lib/dialects/DefaultSql.ts
-var MIGRATION_DATA_TABLE_NAME = "__sqlmorpheus_migrations";
-var DefaultSql = class {
-  canAlterForeignKeys = false;
-  canAlterPrimaryKey = false;
-  canInspectForeignKeys = false;
-  canInspectPrimaryKey = false;
-  typeString = "TEXT";
-  typeInt = "INTEGER";
-  typeBigInt = "BIGINT";
-  typeBoolean = "BOOLEAN";
-  typeNull = "NULL";
-  formatValueToSql(value) {
-    return value.toString();
-  }
-  changeForeignKeysState(enabled) {
-    return "";
-  }
-  async getForeignKeys(tableName, db) {
-    throw new Error("Inspecting foreign keys is not supported!");
-  }
-  addForeignKey(fromTableName, foreignKey) {
-    throw new Error("Adding foreign keys is not supported!");
-  }
-  removeForeignKey(tableName, foreignKeyName) {
-    throw new Error("Foreign key removal is not supported!");
-  }
-  addPrimaryKey(tableName, columnName) {
-    throw new Error("Adding foreign keys is not supported!");
-  }
-  removePrimaryKey(tableName, columnName) {
-    throw new Error("Foreign key removal is not supported!");
-  }
-  foreignKey(column, foreignTable, foreignColumn, onUpdate, onDelete) {
-    let query = `FOREIGN KEY (${column}) REFERENCES ${foreignTable} (${foreignColumn})`;
-    if (onUpdate)
-      query += ` ON UPDATE ${onUpdate}`;
-    if (onDelete)
-      query += ` ON DELETE ${onDelete}`;
-    return query;
-  }
-  createTable(tableName, entries) {
-    return `CREATE TABLE IF NOT EXISTS ${tableName}  (
-	${entries.join(",\n	")}
-);`;
-  }
-  renameTable(tableName, newTableName) {
-    return `ALTER TABLE ${tableName} RENAME TO ${newTableName};`;
-  }
-  dropTable(tableName) {
-    return `DROP TABLE IF EXISTS ${tableName};`;
-  }
-  columnDefinition(columnName, type, defaultValue, isPrimaryKey) {
-    const query = `${columnName} ${type} DEFAULT ${defaultValue}`;
-    return isPrimaryKey ? `${query} PRIMARY KEY` : query;
+  createTableSql(tableName, columns, foreignKeys) {
+    const queryLines = [];
+    for (const columnInfo of columns) {
+      queryLines.push(this.dialect.columnDefinition(columnInfo.name, columnInfo.type, columnInfo.defaultValue, columnInfo.isPrimaryKey));
+    }
+    if (foreignKeys) {
+      for (const foreignKeyInfo of foreignKeys) {
+        queryLines.push(this.dialect.foreignKey(foreignKeyInfo.fromColumn, foreignKeyInfo.toTable, foreignKeyInfo.toColumn.toString(), foreignKeyInfo.onUpdate, foreignKeyInfo.onDelete));
+      }
+    }
+    return this.dialect.createTable(tableName, queryLines);
   }
-  createColumn(columnTable, entry) {
-    return `ALTER TABLE ${columnTable} ADD ${entry};`;
+  /**
+   * Checks if the specified table does not exist in the list of existing tables.
+   *
+   * @param tableName - The name of the table to check.
+   * @return Returns true if the table does not exist, otherwise false.
+   */
+  tableDoesNotExists(tableName) {
+    return this.existingTables.indexOf(tableName) == -1;
   }
-  renameColumn(tableName, oldColumnName, newColumnName) {
-    return `ALTER TABLE ${tableName} RENAME COLUMN ${newColumnName} TO ${oldColumnName};`;
+  /**
+   * Recreates database tables that have been flagged to be recreated in migration data.
+   * This method generated the necessary SQL code for backing up the current table data, dropping and recreating
+   * the tables, and reinserting the preserved data into the recreated tables.
+   */
+  async recreateTables() {
+    const changes = {
+      up: "\n\n-- Recreate tables\n",
+      down: "\n\n-- Recreate tables\n"
+    };
+    const migrationData = this.migrations.getMigrationData();
+    for (const tableName in migrationData) {
+      const migrationEntry = migrationData[tableName];
+      if (!migrationEntry.recreate)
+        continue;
+      this.migrations.verifyMigration(tableName, "recreateTable");
+      if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
+        this.migrations.verifyMigration(tableName, "continueWithoutRollback");
+      const oldColumnList = await this.dialect.getColumnInformation(tableName);
+      const newColumnList = this.newTables[tableName].columns;
+      const moveableColumns = newColumnList.filter((entry) => oldColumnList.find((oldEntry) => oldEntry.name == entry.name) != void 0).map((entry) => entry.name);
+      const backupTableName = `${tableName}__backup`;
+      const insertQuery = this.dialect.insert(
+        backupTableName,
+        this.dialect.insertValues(moveableColumns, this.dialect.select(tableName, moveableColumns))
+      );
+      const moveDataQuery = insertQuery + "\n" + this.dialect.dropTable(tableName) + "\n" + this.dialect.renameTable(backupTableName, tableName);
+      const structure = this.newTables[tableName];
+      changes.up += this.createTableSql(backupTableName, structure.columns, structure.foreignKeys) + "\n" + moveDataQuery;
+      changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(backupTableName, await this.dialect.getColumnInformation(tableName), await this.dialect.getForeignKeys(tableName)) + "\n" + moveDataQuery : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
+    }
+    return changes;
   }
-  copyColumn(tableName, oldColumnName, newColumnName) {
-    return `UPDATE ${tableName} SET ${newColumnName} = ${oldColumnName};`;
-  }
-  dropColumn(tableName, columnName) {
-    return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
-  }
-  select(tableName, select, where) {
-    let query = `SELECT ${select.join(",")} FROM ${tableName}`;
-    if (where)
-      query += ` WHERE ${where}`;
-    return `${query};`;
-  }
-  insert(tableName, content) {
-    return `INSERT INTO ${tableName} ${content};`;
-  }
-  insertValues(keys, valueString) {
-    return `(${keys}) ${valueString ?? `VALUES (${keys.map(() => "?").join(",")})`}`;
-  }
-  migrationTableQuery() {
-    return this.createTable(MIGRATION_DATA_TABLE_NAME, [
-      this.columnDefinition("version", this.typeInt, "0", false)
-    ]);
-  }
-  async createMigrationTableIfNeeded(db) {
-    await db.runMultipleWriteStatements(this.migrationTableQuery());
-  }
-  //TODO: untested
-  async getVersion(db) {
-    await this.createMigrationTableIfNeeded(db);
-    const query = this.select(MIGRATION_DATA_TABLE_NAME, ["version"]);
-    const data = await db.runGetStatement(query);
-    return data.length ? data[0].version : 0;
-  }
-  //TODO: untested
-  async setVersion(db, newVersion) {
-    const query = `${this.migrationTableQuery()};
-INSERT INTO ${MIGRATION_DATA_TABLE_NAME} (version) VALUES ${newVersion} WHERE NOT EXISTS (SELECT 1 FROM ${MIGRATION_DATA_TABLE_NAME})
-UNION ALL
-UPDATE ${MIGRATION_DATA_TABLE_NAME} SET version = ${newVersion} WHERE EXISTS (SELECT 1 FROM ${MIGRATION_DATA_TABLE_NAME});
-`;
-    await db.runMultipleWriteStatements(query);
-  }
-};
-
-// src/lib/dialects/SqliteDialect.ts
-var SqliteDialect = class extends DefaultSql {
-  typeBoolean = "INTEGER";
-  typeBigInt = "INTEGER";
-  canAlterForeignKeys = false;
-  canAlterPrimaryKey = false;
-  canInspectForeignKeys = true;
-  canInspectPrimaryKey = true;
-  changeForeignKeysState(enabled) {
-    return `PRAGMA foreign_keys = ${enabled ? "ON" : "OFF"};`;
-  }
-  async getForeignKeys(tableName, db) {
-    const data = await db.runGetStatement(`PRAGMA foreign_key_list(${tableName});`);
-    return data.map((entry) => {
-      return {
-        fromTable: tableName,
-        fromColumn: entry["from"],
-        toTable: entry["table"],
-        toColumn: entry["to"],
-        on_update: entry["on_update"],
-        on_delete: entry["on_delete"]
-      };
-    });
-  }
-  async getTableNames(db) {
-    return (await db.runGetStatement("SELECT name FROM sqlite_master WHERE type = 'table'")).map((obj) => obj.name);
-  }
-  async getColumnInformation(tableName, db) {
-    const data = await db.runGetStatement(`PRAGMA table_info(${tableName})`);
-    return data.map((entry) => {
-      return {
-        name: entry["name"],
-        type: entry["type"],
-        defaultValue: entry["dflt_value"],
-        isPrimaryKey: entry["pk"] == "1"
-      };
-    });
-  }
-  formatValueToSql(value) {
-    switch (typeof value) {
-      case "boolean":
-        return value ? "1" : "0";
-      default:
-        return value.toString();
+  /**
+   * Migrates foreign key constraints for all defined tables.
+   */
+  async migrateForeignKeys() {
+    if (!this.dialect.canAlterForeignKeys)
+      return { up: "", down: "" };
+    let changes = {
+      up: "\n\n-- Foreign keys\n",
+      down: "\n\n-- Foreign keys\n"
+    };
+    for (const tableName in this.newTables) {
+      if (this.migrations.willBeRecreated(tableName) || this.tableDoesNotExists(tableName))
+        continue;
+      const structure = this.newTables[tableName];
+      const newForeignKeys = structure.foreignKeys ?? [];
+      const oldForeignKeys = await this.dialect.getForeignKeys(tableName);
+      let checkForNewForeignKeys = true;
+      for (const oldForeignKey of oldForeignKeys) {
+        const newForeignKey = newForeignKeys.find((entry) => entry.fromColumn == oldForeignKey.fromColumn);
+        if (!newForeignKey) {
+          Logger.log(`Foreign key ${oldForeignKey.toTable}.${oldForeignKey.toColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} was removed!`);
+          this.migrations.verifyMigration(tableName, "removeForeignKey");
+          if (this.dialect.canAlterForeignKeys) {
+            changes.up += this.dialect.removeForeignKey(oldForeignKey.fromTable, oldForeignKey.fromColumn);
+            changes.down += this.dialect.addForeignKey(
+              oldForeignKey.fromTable,
+              this.dialect.foreignKey(oldForeignKey.fromColumn, oldForeignKey.toTable, oldForeignKey.toColumn, oldForeignKey.onUpdate, oldForeignKey.onDelete)
+            );
+          } else {
+            this.migrations.recreateTableImp(structure.table);
+            checkForNewForeignKeys = false;
+          }
+        } else {
+          if (!newForeignKey || oldForeignKey.toColumn != newForeignKey.toColumn || (oldForeignKey.onUpdate ?? "NO ACTION") != (newForeignKey.onUpdate ?? "NO ACTION") || (oldForeignKey.onDelete ?? "NO ACTION") != (newForeignKey.onDelete ?? "NO ACTION")) {
+            Logger.log(`Foreign key ${oldForeignKey.toTable}.${oldForeignKey.toColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} was changed!`);
+            this.migrations.verifyMigration(tableName, "alterForeignKey");
+            if (this.dialect.canAlterForeignKeys) {
+              changes.up += this.dialect.removeForeignKey(oldForeignKey.fromTable, oldForeignKey.fromColumn) + this.dialect.addForeignKey(
+                newForeignKey.fromTable,
+                this.dialect.foreignKey(newForeignKey.fromColumn, newForeignKey.toTable, newForeignKey.toColumn, newForeignKey.onUpdate, newForeignKey.onDelete)
+              );
+              changes.down += this.dialect.addForeignKey(
+                oldForeignKey.fromTable,
+                this.dialect.foreignKey(oldForeignKey.fromColumn, oldForeignKey.toTable, oldForeignKey.toColumn, oldForeignKey.onUpdate, oldForeignKey.onDelete)
+              ) + this.dialect.removeForeignKey(newForeignKey.fromTable, newForeignKey.fromColumn);
+            } else {
+              this.migrations.recreateTableImp(structure.table);
+              checkForNewForeignKeys = false;
+            }
+          }
+        }
+      }
+      if (checkForNewForeignKeys) {
+        for (const newForeignKey of newForeignKeys) {
+          const oldForeignKey = oldForeignKeys.find((entry) => entry.fromColumn == newForeignKey.fromColumn);
+          if (oldForeignKey)
+            continue;
+          Logger.log(`Foreign key ${newForeignKey.toTable}.${newForeignKey.toColumn} to ${newForeignKey.toTable}.${newForeignKey.toColumn} is new!`);
+          if (this.dialect.canAlterForeignKeys) {
+            changes.up += this.dialect.addForeignKey(
+              newForeignKey.toTable,
+              this.dialect.foreignKey(newForeignKey.fromColumn, newForeignKey.toTable, newForeignKey.toColumn, newForeignKey.onUpdate, newForeignKey.onDelete)
+            );
+            changes.down += this.dialect.removeForeignKey(newForeignKey.fromTable, newForeignKey.fromColumn);
+          } else {
+            this.migrations.recreateTableImp(structure.table);
+            break;
+          }
+        }
+      }
     }
-  }
-  async getVersion(db) {
-    const output = await db.runGetStatement(`PRAGMA user_version;`);
-    return output[0].user_version;
-  }
-  async setVersion(db, newVersion) {
-    await db.runMultipleWriteStatements(`PRAGMA user_version = ${newVersion};`);
-  }
-};
-
-// src/lib/dialects/PostgresDialect.ts
-var PostgresDialect = class extends DefaultSql {
-  canAlterForeignKeys = true;
-  canAlterPrimaryKey = true;
-  canInspectForeignKeys = false;
-  canInspectPrimaryKey = false;
-  changeForeignKeysState(enabled) {
-    return `SET session_replication_role = '${enabled ? "replica" : "origin"}';`;
-  }
-  addForeignKey(fromTableName, foreignKey) {
-    return `ALTER TABLE ${fromTableName} ADD CONSTRAINT ${fromTableName} ${foreignKey};`;
-  }
-  removeForeignKey(tableName, foreignKeyName) {
-    return `ALTER TABLE ${tableName} DROP CONSTRAINT ${foreignKeyName};`;
-  }
-  async getTableNames(db) {
-    return await db.runGetStatement("SELECT table_name FROM information_schema.tables WHERE table_schema='public' AND table_type='BASE TABLE';");
-  }
-  async getColumnInformation(tableName, db) {
-    const data = await db.runGetStatement(`SELECT column_name, data_type, column_default FROM information_schema.columns WHERE table_schema = 'public' AND table_name = '${tableName}';`);
-    return data.map((entry) => {
-      return {
-        name: entry["column_name"],
-        type: entry["data_type"],
-        defaultValue: entry["column_default"],
-        isPrimaryKey: false
-      };
-    });
-  }
-  addPrimaryKey(tableName, columnName) {
-    return `ALTER TABLE ${tableName} ADD PRIMARY KEY (${columnName});
-`;
-  }
-  removePrimaryKey(tableName, columnName) {
-    return `ALTER TABLE ${tableName} DROP CONSTRAINT ${columnName};
-`;
-  }
-};
-
-// src/lib/dialects/MsSqlDialect.ts
-var MsSqlDialect = class extends DefaultSql {
-  canAlterForeignKeys = true;
-  canAlterPrimaryKey = true;
-  canInspectForeignKeys = true;
-  canInspectPrimaryKey = false;
-  changeForeignKeysState(enabled) {
-    return `EXEC sp_MSforeachtable "${enabled ? "ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all" : "ALTER TABLE ? NOCHECK CONSTRAINT all"}"`;
-  }
-  async getForeignKeys(tableName, db) {
-    const data = await db.runGetStatement(`EXEC sp_fkeys @fktable_name = ${tableName};`);
-    return data.map((entry) => {
-      return {
-        fromTable: entry[tableName],
-        fromColumn: entry["FKCOLUMN_NAME"],
-        toTable: entry["PKTABLE_NAME"],
-        toColumn: entry["PKCOLUMN_NAME"]
-      };
-    });
-  }
-  addForeignKey(fromTableName, foreignKey) {
-    return `ALTER TABLE ${fromTableName} ADD ${foreignKey};`;
-  }
-  removeForeignKey(tableName, foreignKeyName) {
-    return `ALTER TABLE ${tableName} DROP CONSTRAINT ${foreignKeyName};`;
-  }
-  addPrimaryKey(tableName, columnName) {
-    return `ALTER TABLE ${tableName} ADD CONSTRAINT ${tableName}_primary PRIMARY KEY (${columnName});`;
-  }
-  removePrimaryKey(tableName, columnName) {
-    return `ALTER TABLE ${tableName} DROP CONSTRAINT ${columnName}_primary;`;
-  }
-  async getTableNames(db) {
-    return await db.runGetStatement("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'");
-  }
-  async getColumnInformation(tableName, db) {
-    const data = await db.runGetStatement(`SELECT COLUMN_NAME, DATA_TYPE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = N'${tableName};'`);
-    return data.map((entry) => {
-      return {
-        name: entry["COLUMN_NAME"],
-        type: entry["DATA_TYPE"],
-        defaultValue: entry["COLUMN_DEFAULT"],
-        isPrimaryKey: false
-      };
-    });
-  }
-};
-
-// src/lib/dialects/MySqlDialect.ts
-var MySqlDialect = class extends DefaultSql {
-  canAlterForeignKeys = true;
-  canAlterPrimaryKey = true;
-  canInspectForeignKeys = true;
-  canInspectPrimaryKey = true;
-  changeForeignKeysState(enabled) {
-    return `SET FOREIGN_KEY_CHECKS ${enabled ? "1" : "0"}
-;`;
-  }
-  async getForeignKeys(tableName, db) {
-    const data = await db.runGetStatement(`SELECT TABLE_NAME,COLUMN_NAME,CONSTRAINT_NAME, REFERENCED_TABLE_NAME,REFERENCED_COLUMN_NAME FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE WHERE REFERENCED_TABLE_SCHEMA = (SELECT DATABASE()) AND REFERENCED_TABLE_NAME = '${tableName}';`);
-    return data.map((entry) => {
-      return {
-        fromTable: tableName,
-        fromColumn: entry["COLUMN_NAME"],
-        toTable: entry["REFERENCED_TABLE_NAME"],
-        toColumn: entry["REFERENCED_COLUMN_NAME"]
-      };
-    });
-  }
-  addForeignKey(fromTableName, foreignKey) {
-    return `ALTER TABLE ${fromTableName} ADD ${foreignKey};`;
-  }
-  removeForeignKey(tableName, foreignKeyName) {
-    return `ALTER TABLE ${tableName} DROP FOREIGN KEY ${foreignKeyName};`;
-  }
-  addPrimaryKey(tableName, columnName) {
-    return `ALTER TABLE ${tableName} PRIMARY KEY (${columnName});`;
-  }
-  removePrimaryKey(tableName, _columnName) {
-    return `ALTER TABLE ${tableName} PRIMARY KEY;`;
-  }
-  async getTableNames(db) {
-    return await db.runGetStatement("SHOW TABLES;");
-  }
-  async getColumnInformation(tableName, db) {
-    const data = await db.runGetStatement(`SHOW COLUMNS FROM ${tableName};`);
-    return data.map((entry) => {
-      return {
-        name: entry["Field"],
-        type: entry["Type"],
-        defaultValue: entry["Default"],
-        isPrimaryKey: entry["Key"] == "PRI"
-      };
-    });
-  }
-};
-
-// src/lib/getDialect.ts
-function getDialect(dbInstructions) {
-  switch (dbInstructions.dialect) {
-    case "Sqlite":
-      return new SqliteDialect();
-    case "Postgres":
-      return new PostgresDialect();
-    case "MsSql":
-      return new MsSqlDialect();
-    case "MySql":
-      return new MySqlDialect();
-    default:
-      throw new Error(`Unknown dialect ${dbInstructions.dialect}`);
-  }
-}
-
-// src/lib/MigrationManager.ts
-var MigrationManager = class {
-  migrations = new Migrations();
-  tableStructureGenerator;
-  existingTables = [];
-  db;
-  dbInstructions;
-  migrationHistoryManager;
-  dialect;
-  constructor(db, dbInstructions) {
-    this.dialect = getDialect(dbInstructions);
-    this.db = db;
-    this.dbInstructions = dbInstructions;
-    this.tableStructureGenerator = new TableStructureGenerator(dbInstructions, this.dialect);
-    this.migrationHistoryManager = new MigrationHistoryManager(this.dbInstructions.configPath);
+    return changes;
   }
   /**
-   * Generates the SQL changes required to migrate a database from its current version
-   * to the target version defined in the database instructions. Handles the creation
-   * and deletion of tables, migration of foreign keys and columns, renaming of columns,
-   * and recreating tables, along with executing any pre- and post-migration custom logic.
-   *
-   * @return A promise that resolves to an object containing the SQL
-   * changes for the migration (`up` and `down` changes) or null if no migration is required.
-   * Throws an error in scenarios such as attempting to migrate to a lower version
-   * or an invalid starting version.
+   * Checks all columns of all tables, creates them if they do not exist in the database and modifies them if needed.
+   * If types, default values or primary key change, the table is recreated
    */
-  async getMigrateSql() {
-    if (this.dbInstructions.version <= 0)
-      throw new Error("Cannot migrate to version 0 or lower");
-    const fromVersion = await this.dialect.getVersion(this.db);
-    if (fromVersion == 0) {
-      Logger.log(`Creating initial migration to version ${this.dbInstructions.version}`);
-      return this.createAndDropTables();
-    }
-    if (fromVersion == this.dbInstructions.version) {
-      Logger.log("Version has not changed. No migrations needed.");
-      return null;
-    }
-    if (fromVersion > this.dbInstructions.version)
-      throw new Error(`You cannot create new migrations with a lower version (from ${fromVersion} to ${this.dbInstructions.version})`);
-    Logger.log(`Creating migration SQL from version ${fromVersion} to ${this.dbInstructions.version}`);
-    const db = this.db;
-    await db.createBackup?.(`from_${fromVersion}_to_${this.dbInstructions.version}`);
-    this.existingTables = await this.dialect.getTableNames(this.db);
-    const foreignKeyOffQuery = this.dialect.changeForeignKeysState(false);
+  async migrateColumns() {
     const changes = {
-      up: foreignKeyOffQuery,
-      down: foreignKeyOffQuery
+      up: "\n\n-- Migrate columns\n",
+      down: "\n\n-- Migrate columns\n"
     };
-    const preSQL = this.dbInstructions.preMigration?.(
-      this.migrations,
-      fromVersion,
-      this.dbInstructions.version
-    );
-    if (preSQL) {
-      changes.up += `
-
--- Custom SQL from preMigration()
-${preSQL.up}`;
-      changes.down += `
-
--- Custom SQL from preMigration()
-${preSQL.down}`;
-    }
-    [
-      await this.createAndDropTables(),
-      await this.migrateForeignKeys(),
-      await this.migrateColumns(),
-      this.renameColumns(),
-      await this.recreateTables()
-    ].forEach((entry) => {
-      changes.up += entry.up;
-      changes.down += entry.down;
-    });
-    const postSql = this.dbInstructions.postMigration?.(fromVersion, this.dbInstructions.version);
-    if (postSql) {
-      changes.up += `
-
--- Custom SQL from postMigration()
-${postSql.up}`;
-      changes.down += `
-
--- Custom SQL from postMigration()
-${postSql.down}`;
+    for (const tableName in this.newTables) {
+      if (this.migrations.willBeRecreated(tableName) || this.tableDoesNotExists(tableName))
+        continue;
+      const newTableDefinition = this.newTables[tableName];
+      const oldColumnList = await this.dialect.getColumnInformation(tableName);
+      const oldPrimaryKey = this.dialect.canInspectPrimaryKey ? this.getPrimaryKeyColumn(oldColumnList) : false;
+      const newColumnList = newTableDefinition.columns;
+      const newPrimaryKey = newTableDefinition.primaryKey;
+      if (this.dialect.canInspectPrimaryKey && oldPrimaryKey != newPrimaryKey) {
+        Logger.log(`Primary key in ${tableName} was changed from ${oldPrimaryKey} to ${newPrimaryKey}!`);
+        this.migrations.verifyMigration(tableName, "alterPrimaryKey");
+        if (this.dialect.canAlterPrimaryKey) {
+          if (oldPrimaryKey) {
+            changes.up += this.dialect.removePrimaryKey(tableName, oldPrimaryKey);
+            changes.down += this.dialect.addPrimaryKey(tableName, oldPrimaryKey);
+          }
+          if (newPrimaryKey) {
+            changes.up += this.dialect.addPrimaryKey(tableName, newPrimaryKey.toString());
+            changes.down += this.dialect.removePrimaryKey(tableName, newPrimaryKey.toString());
+          }
+        } else
+          this.migrations.recreateTableImp(newTableDefinition.table);
+        continue;
+      }
+      for (const newColumn of newColumnList) {
+        const oldColumn = oldColumnList.find(
+          (entry) => this.migrations.getUpdatedColumnName(tableName, entry.name) == newColumn.name
+        );
+        if (oldColumn == void 0) {
+          changes.up += this.dialect.createColumn(tableName, this.dialect.columnDefinition(newColumn.name, newColumn.type, newColumn.defaultValue, newColumn.isPrimaryKey)) + "\n";
+          changes.down += this.dialect.dropColumn(tableName, newColumn.name) + "\n";
+        } else if (newColumn.type != oldColumn.type || newColumn.defaultValue != oldColumn.defaultValue) {
+          this.migrations.recreateTableImp(newTableDefinition.table);
+        }
+      }
+      for (const oldColumn of oldColumnList) {
+        const newColumn = newColumnList.find(
+          (entry) => entry.name == this.migrations.getUpdatedColumnName(tableName, oldColumn.name)
+        );
+        if (newColumn == void 0) {
+          this.migrations.verifyMigration(tableName, "dropColumn");
+          changes.up += this.dialect.dropColumn(tableName, oldColumn.name) + "\n";
+          changes.down += this.dialect.createColumn(tableName, this.dialect.columnDefinition(oldColumn.name, oldColumn.type, oldColumn.defaultValue, oldColumn.isPrimaryKey)) + "\n";
+        }
+      }
     }
-    const foreignKeyOnQuery = this.dialect.changeForeignKeysState(true);
-    changes.up += `
-
-${foreignKeyOnQuery}`;
-    changes.down += `
-
-${foreignKeyOnQuery}`;
     return changes;
   }
   /**
-   * Prepares the migration by generating the SQL changes and creating a migration history entry.
-   * If no changes are needed, the method exits early.
+   * Retrieves the name of the primary key column from a list of column information.
    *
-   * @param overwriteExisting - Optional flag indicating if overwriting existing changes is allowed.
-   * @return - A promise that resolves once the migration preparation is complete.
+   * @param columnInfoList - An array of ColumnInfo objects containing details about each column.
+   * @return The name of the primary key column if found; otherwise, undefined.
    */
-  async prepareMigration(overwriteExisting) {
-    const changes = await this.getMigrateSql();
-    if (!changes)
-      return;
-    const fromVersion = await this.dialect.getVersion(this.db);
-    this.migrationHistoryManager.createMigrationHistory(fromVersion, this.dbInstructions.version, changes, overwriteExisting);
+  getPrimaryKeyColumn(columnInfoList) {
+    for (const columnInfo of columnInfoList) {
+      if (columnInfo.isPrimaryKey)
+        return columnInfo.name;
+    }
   }
   /**
-   * Generates SQL change statements for creating and dropping tables based on the current table structure
-   * and existing table configurations in the database. The `up` changes include SQL statements for creating
-   * new tables, while the `down` changes include SQL statements for dropping the corresponding tables or
-   * recreating them if necessary.
-   *
-   * @return {Promise<SqlChanges>} A promise that resolves to an object containing `up` and `down` SQL
-   * change statements for migrating the database schema.
+   * Handles the renaming of columns in database tables by generating SQL changes for both applying and reverting the renames.
+   * Skips tables that are marked for recreation.
    */
-  async createAndDropTables() {
-    let changes = {
-      up: "\n\n-- Create tables\n",
-      down: "\n\n-- Create tables\n"
+  renameColumns() {
+    const changes = {
+      up: "\n\n-- Rename columns\n",
+      down: "\n\n-- Rename columns\n"
     };
-    for (const tableName in this.tableStructureGenerator.tables) {
-      if (this.tableDoesNotExists(tableName)) {
-        const structure = this.tableStructureGenerator.tables[tableName];
-        changes.up += `${this.createTableSql(tableName, structure.columns, structure.foreignKeys)}
-`;
-        changes.down += `${this.dialect.dropTable(tableName)}
-`;
-      }
-    }
-    for (const tableName of this.existingTables) {
-      if (!this.tableStructureGenerator.tables[tableName]) {
-        this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "dropTable");
-        if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
-          this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "continueWithoutRollback");
-        changes.up += `${this.dialect.dropTable(tableName)}
-`;
-        changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(tableName, await this.dialect.getColumnInformation(tableName, this.db), await this.dialect.getForeignKeys(tableName, this.db)) : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
-      }
+    const migrationData = this.migrations.getMigrationData();
+    for (const tableName in migrationData) {
+      if (migrationData[tableName].recreate)
+        continue;
+      this.migrations.loopRenamedColumns(tableName, (oldColumnName, newColumnName) => {
+        changes.up += this.dialect.renameColumn(tableName, oldColumnName, newColumnName);
+        changes.down += this.dialect.renameColumn(tableName, newColumnName, oldColumnName);
+      });
     }
     return changes;
   }
+};
+
+// src/lib/MigrationHistoryManager.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { readFileSync } from "fs";
+var FILENAME_UP_PREFIX = "up_to_";
+var FILENAME_DOWN_PREFIX = "down_to_";
+var MigrationHistoryManager = class {
+  configPath;
+  migrationsPath;
+  constructor(configPath) {
+    this.configPath = configPath;
+    this.migrationsPath = `${configPath}/migrations`;
+    mkdirSync(this.configPath, { recursive: true });
+    mkdirSync(this.migrationsPath, { recursive: true });
+  }
   /**
-   * Generates an SQL string to create a table with the specified schema.
+   * Creates migration history files for upgrading and downgrading database schemas.
    *
-   * @param tableName - The name of the table to be created.
-   * @param columns - An array of objects defining the columns of the table, including their names, types
-   * default values, and whether they are primary keys.
-   * @param foreignKeys - An optional array of objects defining the foreign key constraints for the table,
-   * including the source column, target table, target column, action on update, and action on delete.
-   * @return The complete SQL string to create the table with the specified structure and constraints.
+   * @param fromVersion - The current version number of the database.
+   * @param toVersion - The target version number for the migration.
+   * @param changes - An object containing the SQL changes for upgrading (`changes.up`) and downgrading (`changes.down`).
+   * @param overwriteExisting - A flag that determines if existing migration files should be overwritten. Defaults to `false`.
    */
-  createTableSql(tableName, columns, foreignKeys) {
-    const queryLines = [];
-    for (const columnInfo of columns) {
-      queryLines.push(this.dialect.columnDefinition(columnInfo.name, columnInfo.type, columnInfo.defaultValue, columnInfo.isPrimaryKey));
-    }
-    if (foreignKeys) {
-      for (const foreignKeyInfo of foreignKeys) {
-        queryLines.push(this.dialect.foreignKey(foreignKeyInfo.fromColumn, foreignKeyInfo.toTable, foreignKeyInfo.toColumn.toString(), foreignKeyInfo.onUpdate, foreignKeyInfo.onDelete));
-      }
-    }
-    return this.dialect.createTable(tableName, queryLines);
+  createMigrationHistory(fromVersion, toVersion, changes, overwriteExisting) {
+    const upPath = `${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion}.sql`;
+    const downPath = `${this.migrationsPath}/${FILENAME_DOWN_PREFIX}${fromVersion}.sql`;
+    if (existsSync(upPath) && !overwriteExisting)
+      throw new Error(`Migration ${upPath} already exists!`);
+    else if (existsSync(downPath) && !overwriteExisting)
+      throw new Error(`Migration ${downPath} already exists!`);
+    Logger.log(`Save migrations to ${this.migrationsPath}`);
+    writeFileSync(`${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion}.sql`, `-- From: Version ${fromVersion}
+-- To:   Version ${toVersion}
+${changes.up}`, { encoding: "utf-8" });
+    writeFileSync(`${this.migrationsPath}/${FILENAME_DOWN_PREFIX}${fromVersion}.sql`, `-- From: Version ${toVersion}
+-- To:   Version ${fromVersion}
+${changes.down}`, { encoding: "utf-8" });
   }
   /**
-   * Checks if the specified table does not exist in the list of existing tables.
+   * Retrieves the SQL migration script for upgrading to the specified version.
+   * If no version is provided, it retrieves the migration script for the latest version in the history.
    *
-   * @param tableName - The name of the table to check.
-   * @return Returns true if the table does not exist, otherwise false.
+   * @param toVersion - The version of the migration script to retrieve. If not specified, the latest version is used.
+   * @return The content of the SQL migration script as a string.
    */
-  tableDoesNotExists(tableName) {
-    return this.existingTables.indexOf(tableName) == -1;
+  getUpMigration(toVersion) {
+    return readFileSync(`${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion}.sql`, { encoding: "utf-8" });
   }
   /**
-   * Recreates database tables that have been flagged to be recreated in migration data.
-   * This method generated the necessary SQL code for backing up the current table data, dropping and recreating
-   * the tables, and reinserting the preserved data into the recreated tables.
+   * Retrieves the SQL migration script for downgrading to the specified version.
+   *
+   * @param version - The version number of the migration to retrieve.
+   * @return The SQL script for the down migration.
    */
-  async recreateTables() {
-    const changes = {
-      up: "\n\n-- Recreate tables\n",
-      down: "\n\n-- Recreate tables\n"
-    };
-    const migrationData = this.migrations.getMigrationData();
-    for (const tableName in migrationData) {
-      const migrationEntry = migrationData[tableName];
-      if (!migrationEntry.recreate)
-        continue;
-      this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "recreateTable");
-      if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
-        this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "continueWithoutRollback");
-      const oldColumnList = await this.dialect.getColumnInformation(tableName, this.db);
-      const newColumnList = this.tableStructureGenerator.tables[tableName].columns;
-      const moveableColumns = newColumnList.filter((entry) => oldColumnList.find((oldEntry) => oldEntry.name == entry.name) != void 0).map((entry) => entry.name);
-      const backupTableName = `${tableName}__backup`;
-      const insertQuery = this.dialect.insert(
-        backupTableName,
-        this.dialect.insertValues(moveableColumns, this.dialect.select(tableName, moveableColumns))
-      );
-      const moveDataQuery = insertQuery + "\n" + this.dialect.dropTable(tableName) + "\n" + this.dialect.renameTable(backupTableName, tableName);
-      const structure = this.tableStructureGenerator.tables[tableName];
-      changes.up += this.createTableSql(backupTableName, structure.columns, structure.foreignKeys) + "\n" + moveDataQuery;
-      changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(backupTableName, await this.dialect.getColumnInformation(tableName, this.db), await this.dialect.getForeignKeys(tableName, this.db)) + "\n" + moveDataQuery : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
-    }
-    return changes;
+  getDownMigration(version) {
+    return readFileSync(`${this.migrationsPath}/${FILENAME_DOWN_PREFIX}${version}.sql`, { encoding: "utf-8" });
   }
-  /**
-   * Migrates foreign key constraints for all defined tables.
-   */
-  async migrateForeignKeys() {
-    if (!this.dialect.canAlterForeignKeys)
-      return { up: "", down: "" };
-    let changes = {
-      up: "\n\n-- Foreign keys\n",
-      down: "\n\n-- Foreign keys\n"
-    };
-    for (const tableName in this.tableStructureGenerator.tables) {
-      if (this.migrations.willBeRecreated(tableName) || this.tableDoesNotExists(tableName))
-        continue;
-      const structure = this.tableStructureGenerator.tables[tableName];
-      const newForeignKeys = structure.foreignKeys ?? [];
-      const oldForeignKeys = await this.dialect.getForeignKeys(tableName, this.db);
-      let checkForNewForeignKeys = true;
-      for (const oldForeignKey of oldForeignKeys) {
-        const newForeignKey = newForeignKeys.find((entry) => entry.fromColumn == oldForeignKey.fromColumn);
-        if (!newForeignKey) {
-          Logger.log(`Foreign key ${oldForeignKey.toTable}.${oldForeignKey.toColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} was removed!`);
-          this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "removeForeignKey");
-          if (this.dialect.canAlterForeignKeys) {
-            changes.up += this.dialect.removeForeignKey(oldForeignKey.fromTable, oldForeignKey.fromColumn);
-            changes.down += this.dialect.addForeignKey(
-              oldForeignKey.fromTable,
-              this.dialect.foreignKey(oldForeignKey.fromColumn, oldForeignKey.toTable, oldForeignKey.toColumn, oldForeignKey.onUpdate, oldForeignKey.onDelete)
-            );
-          } else {
-            this.migrations.recreateTable(structure.table);
-            checkForNewForeignKeys = false;
-          }
-        } else {
-          if (!newForeignKey || oldForeignKey.toColumn != newForeignKey.toColumn || (oldForeignKey.onUpdate ?? "NO ACTION") != (newForeignKey.onUpdate ?? "NO ACTION") || (oldForeignKey.onDelete ?? "NO ACTION") != (newForeignKey.onDelete ?? "NO ACTION")) {
-            Logger.log(`Foreign key ${oldForeignKey.toTable}.${oldForeignKey.toColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} was changed!`);
-            this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "alterForeignKey");
-            if (this.dialect.canAlterForeignKeys) {
-              changes.up += this.dialect.removeForeignKey(oldForeignKey.fromTable, oldForeignKey.fromColumn) + this.dialect.addForeignKey(
-                newForeignKey.fromTable,
-                this.dialect.foreignKey(newForeignKey.fromColumn, newForeignKey.toTable, newForeignKey.toColumn, newForeignKey.onUpdate, newForeignKey.onDelete)
-              );
-              changes.down += this.dialect.addForeignKey(
-                oldForeignKey.fromTable,
-                this.dialect.foreignKey(oldForeignKey.fromColumn, oldForeignKey.toTable, oldForeignKey.toColumn, oldForeignKey.onUpdate, oldForeignKey.onDelete)
-              ) + this.dialect.removeForeignKey(newForeignKey.fromTable, newForeignKey.fromColumn);
-            } else {
-              this.migrations.recreateTable(structure.table);
-              checkForNewForeignKeys = false;
-            }
-          }
-        }
-      }
-      if (checkForNewForeignKeys) {
-        for (const newForeignKey of newForeignKeys) {
-          const oldForeignKey = oldForeignKeys.find((entry) => entry.fromColumn == newForeignKey.fromColumn);
-          if (oldForeignKey)
-            continue;
-          Logger.log(`Foreign key ${newForeignKey.toTable}.${newForeignKey.toColumn} to ${newForeignKey.toTable}.${newForeignKey.toColumn} is new!`);
-          if (this.dialect.canAlterForeignKeys) {
-            changes.up += this.dialect.addForeignKey(
-              newForeignKey.toTable,
-              this.dialect.foreignKey(newForeignKey.fromColumn, newForeignKey.toTable, newForeignKey.toColumn, newForeignKey.onUpdate, newForeignKey.onDelete)
-            );
-            changes.down += this.dialect.removeForeignKey(newForeignKey.fromTable, newForeignKey.fromColumn);
-          } else {
-            this.migrations.recreateTable(structure.table);
-            break;
-          }
-        }
+};
+
+// src/lib/tableInfo/decorators/DbTable.ts
+import "polyfill-symbol-metadata";
+function DbTable(tableName, primaryKey) {
+  return (table, context) => {
+    Object.defineProperty(table, "name", { value: tableName, writable: false });
+    const tableInfo = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
+    tableInfo.primaryKey = primaryKey?.toString();
+    if (tableInfo.foreignKeys) {
+      for (const foreignKey of tableInfo.foreignKeys) {
+        foreignKey.fromTable = tableName;
       }
     }
-    return changes;
+  };
+}
+
+// src/lib/tableInfo/decorators/ForeignKey.ts
+import "polyfill-symbol-metadata";
+function ForeignKey(toTable, toColumn, onDelete, onUpdate) {
+  return (table, context) => {
+    const metadata = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
+    if (!metadata.foreignKeys)
+      metadata.foreignKeys = [];
+    metadata.foreignKeys.push({
+      fromTable: "",
+      fromColumn: context.name ?? context,
+      //to stay compatible with old decorator structure (see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#decorator-metadata)
+      toTable: toTable.name,
+      toColumn: toColumn.toString(),
+      onDelete,
+      onUpdate
+    });
+  };
+}
+
+// src/lib/dialects/DefaultSql.ts
+var MIGRATION_DATA_TABLE_NAME = "__sqlmorpheus_migrations";
+var DefaultSql = class {
+  db;
+  canAlterForeignKeys = false;
+  canAlterPrimaryKey = false;
+  canInspectForeignKeys = false;
+  canInspectPrimaryKey = false;
+  typeString = "TEXT";
+  typeInt = "INTEGER";
+  typeBigInt = "BIGINT";
+  typeBoolean = "BOOLEAN";
+  typeNull = "NULL";
+  constructor(db) {
+    this.db = db;
+  }
+  formatValueToSql(value) {
+    return value.toString();
+  }
+  changeForeignKeysState(enabled) {
+    return "";
+  }
+  addForeignKey(fromTableName, foreignKey) {
+    throw new Error("Adding foreign keys is not supported!");
+  }
+  removeForeignKey(tableName, foreignKeyName) {
+    throw new Error("Foreign key removal is not supported!");
+  }
+  addPrimaryKey(tableName, columnName) {
+    throw new Error("Adding foreign keys is not supported!");
+  }
+  removePrimaryKey(tableName, columnName) {
+    throw new Error("Foreign key removal is not supported!");
+  }
+  foreignKey(column, foreignTable, foreignColumn, onUpdate, onDelete) {
+    let query = `FOREIGN KEY (${column}) REFERENCES ${foreignTable} (${foreignColumn})`;
+    if (onUpdate)
+      query += ` ON UPDATE ${onUpdate}`;
+    if (onDelete)
+      query += ` ON DELETE ${onDelete}`;
+    return query;
+  }
+  createTable(tableName, entries) {
+    return `CREATE TABLE IF NOT EXISTS ${tableName}  (
+	${entries.join(",\n	")}
+);`;
+  }
+  renameTable(tableName, newTableName) {
+    return `ALTER TABLE ${tableName} RENAME TO ${newTableName};`;
+  }
+  dropTable(tableName) {
+    return `DROP TABLE IF EXISTS ${tableName};`;
+  }
+  columnDefinition(columnName, type, defaultValue, isPrimaryKey) {
+    const query = `${columnName} ${type} DEFAULT ${defaultValue}`;
+    return isPrimaryKey ? `${query} PRIMARY KEY` : query;
+  }
+  createColumn(columnTable, entry) {
+    return `ALTER TABLE ${columnTable} ADD ${entry};`;
+  }
+  renameColumn(tableName, oldColumnName, newColumnName) {
+    return `ALTER TABLE ${tableName} RENAME COLUMN ${oldColumnName} TO ${newColumnName};`;
+  }
+  copyColumn(tableName, oldColumnName, newColumnName) {
+    return `UPDATE ${tableName} SET ${newColumnName} = ${oldColumnName};`;
+  }
+  dropColumn(tableName, columnName) {
+    return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
+  }
+  select(tableName, select, where) {
+    let query = `SELECT ${select.join(",")} FROM ${tableName}`;
+    if (where)
+      query += ` WHERE ${where}`;
+    return `${query};`;
+  }
+  insert(tableName, content) {
+    return `INSERT INTO ${tableName} ${content};`;
+  }
+  insertValues(keys, valueString) {
+    return `(${keys}) ${valueString ?? `VALUES (${keys.map(() => "?").join(",")})`}`;
+  }
+  migrationTableQuery() {
+    return this.createTable(MIGRATION_DATA_TABLE_NAME, [
+      this.columnDefinition("version", this.typeInt, "0", false)
+    ]);
+  }
+  async getForeignKeys(tableName) {
+    throw new Error("Inspecting foreign keys is not supported!");
+  }
+  async createMigrationTableIfNeeded() {
+    await this.db.runMultipleWriteStatements(this.migrationTableQuery());
+  }
+  //TODO: untested
+  async getVersion() {
+    await this.createMigrationTableIfNeeded();
+    const query = this.select(MIGRATION_DATA_TABLE_NAME, ["version"]);
+    const data = await this.db.runGetStatement(query);
+    return data.length ? data[0].version : 0;
+  }
+  //TODO: untested
+  async setVersion(newVersion) {
+    const query = `${this.migrationTableQuery()};
+INSERT INTO ${MIGRATION_DATA_TABLE_NAME} (version) VALUES ${newVersion} WHERE NOT EXISTS (SELECT 1 FROM ${MIGRATION_DATA_TABLE_NAME})
+UNION ALL
+UPDATE ${MIGRATION_DATA_TABLE_NAME} SET version = ${newVersion} WHERE EXISTS (SELECT 1 FROM ${MIGRATION_DATA_TABLE_NAME});
+`;
+    await this.db.runMultipleWriteStatements(query);
+  }
+};
+
+// src/lib/dialects/SqliteDialect.ts
+var SqliteDialect = class extends DefaultSql {
+  typeBoolean = "INTEGER";
+  typeBigInt = "INTEGER";
+  canAlterForeignKeys = false;
+  canAlterPrimaryKey = false;
+  canInspectForeignKeys = true;
+  canInspectPrimaryKey = true;
+  changeForeignKeysState(enabled) {
+    return `PRAGMA foreign_keys = ${enabled ? "ON" : "OFF"};`;
+  }
+  async getTableNames() {
+    return (await this.db.runGetStatement("SELECT name FROM sqlite_master WHERE type = 'table'")).map((obj) => obj.name);
+  }
+  async getColumnInformation(tableName) {
+    const data = await this.db.runGetStatement(`PRAGMA table_info(${tableName})`);
+    return data.map((entry) => {
+      return {
+        name: entry["name"],
+        type: entry["type"],
+        defaultValue: entry["dflt_value"],
+        isPrimaryKey: entry["pk"] == "1"
+      };
+    });
   }
-  /**
-   * Checks all columns of all tables, creates them if they do not exist in the database and modifies them if needed.
-   * If types, default values or primary key change, the table is recreated
-   */
-  async migrateColumns() {
-    const changes = {
-      up: "\n\n-- Migrate columns\n",
-      down: "\n\n-- Migrate columns\n"
-    };
-    for (const tableName in this.tableStructureGenerator.tables) {
-      if (this.migrations.willBeRecreated(tableName) || this.tableDoesNotExists(tableName))
-        continue;
-      const newTableDefinition = this.tableStructureGenerator.tables[tableName];
-      const oldColumnList = await this.dialect.getColumnInformation(tableName, this.db);
-      const oldPrimaryKey = this.dialect.canInspectPrimaryKey ? this.getPrimaryKeyColumn(oldColumnList) : false;
-      const newColumnList = newTableDefinition.columns;
-      const newPrimaryKey = newTableDefinition.primaryKey;
-      if (this.dialect.canInspectPrimaryKey && oldPrimaryKey != newPrimaryKey) {
-        Logger.log(`Primary key in ${tableName} was changed from ${oldPrimaryKey} to ${newPrimaryKey}!`);
-        this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "alterPrimaryKey");
-        if (this.dialect.canAlterPrimaryKey) {
-          if (oldPrimaryKey) {
-            changes.up += this.dialect.removePrimaryKey(tableName, oldPrimaryKey);
-            changes.down += this.dialect.addPrimaryKey(tableName, oldPrimaryKey);
-          }
-          if (newPrimaryKey) {
-            changes.up += this.dialect.addPrimaryKey(tableName, newPrimaryKey.toString());
-            changes.down += this.dialect.removePrimaryKey(tableName, newPrimaryKey.toString());
-          }
-        } else
-          this.migrations.recreateTable(newTableDefinition.table);
-        continue;
-      }
-      for (const newColumn of newColumnList) {
-        const oldColumn = oldColumnList.find((entry) => entry.name == newColumn.name);
-        if (oldColumn == void 0) {
-          changes.up += this.dialect.createColumn(tableName, this.dialect.columnDefinition(newColumn.name, newColumn.type, newColumn.defaultValue, newColumn.isPrimaryKey)) + "\n";
-          changes.down += this.dialect.dropColumn(tableName, newColumn.name) + "\n";
-        } else if (newColumn.type != oldColumn.type || newColumn.defaultValue != oldColumn.defaultValue) {
-          this.migrations.recreateTable(newTableDefinition.table);
-        }
-      }
-      for (const oldColumn of oldColumnList) {
-        const newColumn = newColumnList.find((entry) => entry.name == oldColumn.name);
-        if (newColumn == void 0) {
-          this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "dropColumn");
-          changes.up += this.dialect.dropColumn(tableName, oldColumn.name) + "\n";
-          changes.down += this.dialect.createColumn(tableName, this.dialect.columnDefinition(oldColumn.name, oldColumn.type, oldColumn.defaultValue, oldColumn.isPrimaryKey)) + "\n";
-        }
-      }
+  formatValueToSql(value) {
+    switch (typeof value) {
+      case "boolean":
+        return value ? "1" : "0";
+      default:
+        return value.toString();
     }
-    return changes;
   }
-  /**
-   * Retrieves the name of the primary key column from a list of column information.
-   *
-   * @param columnInfoList - An array of ColumnInfo objects containing details about each column.
-   * @return The name of the primary key column if found; otherwise, undefined.
-   */
-  getPrimaryKeyColumn(columnInfoList) {
-    for (const columnInfo of columnInfoList) {
-      if (columnInfo.isPrimaryKey)
-        return columnInfo.name;
-    }
+  async getForeignKeys(tableName) {
+    const data = await this.db.runGetStatement(`PRAGMA foreign_key_list(${tableName});`);
+    return data.map((entry) => {
+      return {
+        fromTable: tableName,
+        fromColumn: entry["from"],
+        toTable: entry["table"],
+        toColumn: entry["to"],
+        on_update: entry["on_update"],
+        on_delete: entry["on_delete"]
+      };
+    });
   }
-  /**
-   * Handles the renaming of columns in database tables by generating SQL changes for both applying and reverting the renames.
-   * Skips tables that are marked for recreation.
-   */
-  renameColumns() {
-    const changes = {
-      up: "\n\n-- Rename columns\n",
-      down: "\n\n-- Rename columns\n"
-    };
-    const migrationData = this.migrations.getMigrationData();
-    for (const tableName in migrationData) {
-      if (migrationData[tableName].recreate)
-        continue;
-      this.migrations.loopRenamedColumns(tableName, (oldColumnName, newColumnName) => {
-        changes.up += this.dialect.renameColumn(tableName, oldColumnName, newColumnName);
-        changes.down += this.dialect.renameColumn(tableName, newColumnName, oldColumnName);
-      });
-    }
-    return changes;
+  async getVersion() {
+    const output = await this.db.runGetStatement(`PRAGMA user_version;`);
+    return output[0].user_version;
+  }
+  async setVersion(newVersion) {
+    await this.db.runMultipleWriteStatements(`PRAGMA user_version = ${newVersion};`);
   }
 };
 
-// src/lib/tableInfo/decorators/DbTable.ts
-import "polyfill-symbol-metadata";
-function DbTable(tableName, primaryKey) {
-  return (table, context) => {
-    Object.defineProperty(table, "name", { value: tableName, writable: false });
-    const tableInfo = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
-    tableInfo.primaryKey = primaryKey?.toString();
-    if (tableInfo.foreignKeys) {
-      for (const foreignKey of tableInfo.foreignKeys) {
-        foreignKey.fromTable = tableName;
-      }
-    }
-  };
-}
+// src/lib/dialects/PostgresDialect.ts
+var PostgresDialect = class extends DefaultSql {
+  canAlterForeignKeys = true;
+  canAlterPrimaryKey = true;
+  canInspectForeignKeys = false;
+  canInspectPrimaryKey = false;
+  changeForeignKeysState(enabled) {
+    return `SET session_replication_role = '${enabled ? "replica" : "origin"}';`;
+  }
+  addForeignKey(fromTableName, foreignKey) {
+    return `ALTER TABLE ${fromTableName} ADD CONSTRAINT ${fromTableName} ${foreignKey};`;
+  }
+  removeForeignKey(tableName, foreignKeyName) {
+    return `ALTER TABLE ${tableName} DROP CONSTRAINT ${foreignKeyName};`;
+  }
+  async getTableNames() {
+    return await this.db.runGetStatement("SELECT table_name FROM information_schema.tables WHERE table_schema='public' AND table_type='BASE TABLE';");
+  }
+  async getColumnInformation(tableName) {
+    const data = await this.db.runGetStatement(`SELECT column_name, data_type, column_default FROM information_schema.columns WHERE table_schema = 'public' AND table_name = '${tableName}';`);
+    return data.map((entry) => {
+      return {
+        name: entry["column_name"],
+        type: entry["data_type"],
+        defaultValue: entry["column_default"],
+        isPrimaryKey: false
+      };
+    });
+  }
+  addPrimaryKey(tableName, columnName) {
+    return `ALTER TABLE ${tableName} ADD PRIMARY KEY (${columnName});
+`;
+  }
+  removePrimaryKey(tableName, columnName) {
+    return `ALTER TABLE ${tableName} DROP CONSTRAINT ${columnName};
+`;
+  }
+};
 
-// src/lib/tableInfo/decorators/ForeignKey.ts
-import "polyfill-symbol-metadata";
-function ForeignKey(toTable, toColumn, onDelete, onUpdate) {
-  return (table, context) => {
-    const metadata = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
-    if (!metadata.foreignKeys)
-      metadata.foreignKeys = [];
-    metadata.foreignKeys.push({
-      fromTable: "",
-      fromColumn: context.name ?? context,
-      //to stay compatible with old decorator structure (see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#decorator-metadata)
-      toTable: toTable.name,
-      toColumn: toColumn.toString(),
-      onDelete,
-      onUpdate
+// src/lib/dialects/MsSqlDialect.ts
+var MsSqlDialect = class extends DefaultSql {
+  canAlterForeignKeys = true;
+  canAlterPrimaryKey = true;
+  canInspectForeignKeys = true;
+  canInspectPrimaryKey = false;
+  changeForeignKeysState(enabled) {
+    return `EXEC sp_MSforeachtable "${enabled ? "ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all" : "ALTER TABLE ? NOCHECK CONSTRAINT all"}"`;
+  }
+  addForeignKey(fromTableName, foreignKey) {
+    return `ALTER TABLE ${fromTableName} ADD ${foreignKey};`;
+  }
+  removeForeignKey(tableName, foreignKeyName) {
+    return `ALTER TABLE ${tableName} DROP CONSTRAINT ${foreignKeyName};`;
+  }
+  addPrimaryKey(tableName, columnName) {
+    return `ALTER TABLE ${tableName} ADD CONSTRAINT ${tableName}_primary PRIMARY KEY (${columnName});`;
+  }
+  removePrimaryKey(tableName, columnName) {
+    return `ALTER TABLE ${tableName} DROP CONSTRAINT ${columnName}_primary;`;
+  }
+  async getForeignKeys(tableName) {
+    const data = await this.db.runGetStatement(`EXEC sp_fkeys @fktable_name = ${tableName};`);
+    return data.map((entry) => {
+      return {
+        fromTable: entry[tableName],
+        fromColumn: entry["FKCOLUMN_NAME"],
+        toTable: entry["PKTABLE_NAME"],
+        toColumn: entry["PKCOLUMN_NAME"]
+      };
     });
-  };
+  }
+  async getTableNames() {
+    return await this.db.runGetStatement("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'");
+  }
+  async getColumnInformation(tableName) {
+    const data = await this.db.runGetStatement(`SELECT COLUMN_NAME, DATA_TYPE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = N'${tableName};'`);
+    return data.map((entry) => {
+      return {
+        name: entry["COLUMN_NAME"],
+        type: entry["DATA_TYPE"],
+        defaultValue: entry["COLUMN_DEFAULT"],
+        isPrimaryKey: false
+      };
+    });
+  }
+};
+
+// src/lib/dialects/MySqlDialect.ts
+var MySqlDialect = class extends DefaultSql {
+  canAlterForeignKeys = true;
+  canAlterPrimaryKey = true;
+  canInspectForeignKeys = true;
+  canInspectPrimaryKey = true;
+  changeForeignKeysState(enabled) {
+    return `SET FOREIGN_KEY_CHECKS ${enabled ? "1" : "0"}
+;`;
+  }
+  addForeignKey(fromTableName, foreignKey) {
+    return `ALTER TABLE ${fromTableName} ADD ${foreignKey};`;
+  }
+  removeForeignKey(tableName, foreignKeyName) {
+    return `ALTER TABLE ${tableName} DROP FOREIGN KEY ${foreignKeyName};`;
+  }
+  addPrimaryKey(tableName, columnName) {
+    return `ALTER TABLE ${tableName} PRIMARY KEY (${columnName});`;
+  }
+  removePrimaryKey(tableName, _columnName) {
+    return `ALTER TABLE ${tableName} PRIMARY KEY;`;
+  }
+  async getForeignKeys(tableName) {
+    const data = await this.db.runGetStatement(`SELECT TABLE_NAME,COLUMN_NAME,CONSTRAINT_NAME, REFERENCED_TABLE_NAME,REFERENCED_COLUMN_NAME FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE WHERE REFERENCED_TABLE_SCHEMA = (SELECT DATABASE()) AND REFERENCED_TABLE_NAME = '${tableName}';`);
+    return data.map((entry) => {
+      return {
+        fromTable: tableName,
+        fromColumn: entry["COLUMN_NAME"],
+        toTable: entry["REFERENCED_TABLE_NAME"],
+        toColumn: entry["REFERENCED_COLUMN_NAME"]
+      };
+    });
+  }
+  async getTableNames() {
+    return await this.db.runGetStatement("SHOW TABLES;");
+  }
+  async getColumnInformation(tableName) {
+    const data = await this.db.runGetStatement(`SHOW COLUMNS FROM ${tableName};`);
+    return data.map((entry) => {
+      return {
+        name: entry["Field"],
+        type: entry["Type"],
+        defaultValue: entry["Default"],
+        isPrimaryKey: entry["Key"] == "PRI"
+      };
+    });
+  }
+};
+
+// src/lib/getDialect.ts
+function getDialect(db, dbInstructions) {
+  switch (dbInstructions.dialect) {
+    case "Sqlite":
+      return new SqliteDialect(db);
+    case "Postgres":
+      return new PostgresDialect(db);
+    case "MsSql":
+      return new MsSqlDialect(db);
+    case "MySql":
+      return new MySqlDialect(db);
+    default:
+      throw new Error(`Unknown dialect ${dbInstructions.dialect}`);
+  }
 }
 
 // src/index.ts
-async function prepareMigration(db, instructions, overwriteExisting) {
-  Logger.setMode(instructions.loggerMode);
-  const mm = new MigrationManager(db, instructions);
-  await mm.prepareMigration(overwriteExisting);
+async function prepareMigration(db, dbInstructions, overwriteExisting) {
+  Logger.setMode(dbInstructions.loggerMode);
+  const dialect = getDialect(db, dbInstructions);
+  const mm = new MigrationManager(dialect);
+  const migration = await mm.generateSqlChanges(dbInstructions);
+  if (!migration)
+    return;
+  const migrationHistoryManager = new MigrationHistoryManager(dbInstructions.configPath);
+  migrationHistoryManager.createMigrationHistory(migration.fromVersion, dbInstructions.version, migration.changes, overwriteExisting);
 }
-async function runPreparedMigrations(db, instructions) {
-  Logger.setMode(instructions.loggerMode);
-  const migrationHistoryManager = new MigrationHistoryManager(instructions.configPath);
-  const dialect = getDialect(instructions);
-  const fromVersion = await dialect.getVersion(db);
-  const toVersion = instructions.version;
+async function runPreparedMigrations(db, dbInstructions) {
+  Logger.setMode(dbInstructions.loggerMode);
+  const historyManager = new MigrationHistoryManager(dbInstructions.configPath);
+  const dialect = getDialect(db, dbInstructions);
+  const fromVersion = await dialect.getVersion();
+  const toVersion = dbInstructions.version;
   if (fromVersion == toVersion)
     return;
+  await db.createBackup?.(`from_${fromVersion}_to_${dbInstructions.version}`);
   Logger.log(`Running migrations from ${fromVersion} to ${toVersion}`);
   for (let i = fromVersion ? fromVersion + 1 : toVersion; i <= toVersion; ++i) {
-    const upChanges = migrationHistoryManager.getUpMigration(i);
+    const upChanges = historyManager.getUpMigration(i);
     Logger.debug(upChanges);
     await db.runMultipleWriteStatements(upChanges);
-    instructions.version = i;
+    dbInstructions.version = i;
   }
-  await dialect.setVersion(db, toVersion);
+  await dialect.setVersion(toVersion);
 }
 async function prepareAndRunMigration(db, instructions, overwriteExisting) {
   Logger.setMode(instructions.loggerMode);
   await prepareMigration(db, instructions, overwriteExisting);
   await runPreparedMigrations(db, instructions);
 }
-async function runMigrationWithoutHistory(db, instructions) {
-  Logger.setMode(instructions.loggerMode);
-  const mm = new MigrationManager(db, instructions);
-  const changes = await mm.getMigrateSql();
-  if (changes)
-    await db.runMultipleWriteStatements(changes.up);
+async function runMigrationWithoutHistory(db, dbInstructions) {
+  Logger.setMode(dbInstructions.loggerMode);
+  const dialect = getDialect(db, dbInstructions);
+  const mm = new MigrationManager(dialect);
+  const migration = await mm.generateSqlChanges(dbInstructions);
+  if (migration) {
+    await db.createBackup?.(`from_${migration.fromVersion}_to_${dbInstructions.version}`);
+    await db.runMultipleWriteStatements(migration.changes.up);
+  }
 }
-async function rollback(db, instructions, toVersion) {
-  Logger.setMode(instructions.loggerMode);
-  const migrationHistoryManager = new MigrationHistoryManager(instructions.configPath);
-  const dialect = getDialect(instructions);
-  const fromVersion = await dialect.getVersion(db);
+async function rollback(db, dbInstructions, toVersion) {
+  Logger.setMode(dbInstructions.loggerMode);
+  const dialect = getDialect(db, dbInstructions);
+  const fromVersion = await dialect.getVersion();
+  const historyManager = new MigrationHistoryManager(dbInstructions.configPath);
+  await db.createBackup?.(`from_${fromVersion}_to_${dbInstructions.version}`);
   Logger.log(`Rolling back from ${fromVersion} to ${toVersion}`);
   for (let i = fromVersion - 1; i >= toVersion; --i) {
-    const upChanges = migrationHistoryManager.getDownMigration(i);
+    const upChanges = historyManager.getDownMigration(i);
     Logger.debug(upChanges);
     await db.runMultipleWriteStatements(upChanges);
-    instructions.version = i;
+    dbInstructions.version = i;
   }
-  await dialect.setVersion(db, toVersion);
+  await dialect.setVersion(toVersion);
 }
 export {
   DbTable,