sqlmorpheus 0.2.5 → 0.2.7

package/dist/index.mjs

@@ -1,40 +1,41 @@
 // src/lib/Logger.ts
 var LoggerClass = class {
-  mode = "normal";
+  mode = "log";
   setMode(mode) {
-    this.mode = mode ?? "normal";
+    this.mode = mode ?? "log";
   }
   debug(text) {
-    if (this.mode == "debug")
-      console.log(text);
+    if (this.mode == "debug") {
+      console.debug(`\x1B[90m${(/* @__PURE__ */ new Date()).toLocaleTimeString()}\x1B[0m ${text}`);
+    }
   }
   log(text) {
-    if (this.mode == "silent" || this.mode == "noLog")
-      return;
-    console.log(text);
+    if (this.mode == "log" || this.mode == "debug") {
+      console.log(`\x1B[90m${(/* @__PURE__ */ new Date()).toLocaleTimeString()}\x1B[0m ${text}`);
+    }
   }
   warn(text) {
-    if (this.mode == "silent")
-      return;
-    console.warn(text);
+    if (this.mode == "warn" || this.mode == "log" || this.mode == "debug") {
+      console.warn(`\x1B[90m${(/* @__PURE__ */ new Date()).toLocaleTimeString()}\x1B[0m ${text}`);
+    }
+  }
+  error(text) {
+    if (this.mode == "error" || this.mode == "warn" || this.mode == "log" || this.mode == "debug") {
+      console.error(`\x1B[90m${(/* @__PURE__ */ new Date()).toLocaleTimeString()}\x1B[0m ${text}`);
+    }
   }
 };
 var Logger = new LoggerClass();
 
-// src/lib/tableInfo/TableObj.ts
-var TableObj = class _TableObj {
-  IS_TABLE_OBJ = true;
-  tableName;
-  tableStructure = {
-    table: "",
-    primaryKey: void 0,
-    columns: {},
-    foreignKeys: []
-  };
+// src/lib/tableInfo/TableObjHelper.ts
+var TableObjHelper = class _TableObjHelper {
+  static isTableObj(obj) {
+    return !!obj?.IS_TABLE_OBJ;
+  }
   static getEmptyColumnEntry(key) {
     return {
       name: key,
-      type: "",
+      sqlType: "",
       defaultValue: "",
       isPrimaryKey: false
     };
@@ -60,55 +61,11 @@ var TableObj = class _TableObj {
         return null;
     }
     return {
-      ..._TableObj.getEmptyColumnEntry(key),
+      ..._TableObjHelper.getEmptyColumnEntry(key),
       inputType: dataType,
       inputDefaultValue: value
     };
   }
-  constructor(tableName, defaultValues) {
-    this.tableName = tableName;
-    this.tableStructure.table = tableName;
-    for (const key in defaultValues) {
-      const value = defaultValues[key];
-      const columnEntry = _TableObj.getColumnEntry(key, value);
-      if (!columnEntry)
-        continue;
-      this.tableStructure.columns[key] = columnEntry;
-    }
-  }
-  primaryKey(key) {
-    if (this.tableStructure.primaryKey) {
-      this.tableStructure.columns[this.tableStructure.primaryKey].isPrimaryKey = false;
-    }
-    this.tableStructure.primaryKey = key.toString();
-    this.tableStructure.columns[key.toString()].isPrimaryKey = true;
-    return this;
-  }
-  foreignKey(fromColumn, toTable, toColumn, options) {
-    this.tableStructure.foreignKeys.push({
-      fromTable: this.tableName,
-      fromColumn: fromColumn.toString(),
-      toTable: toTable.tableName,
-      toColumn: toColumn.toString(),
-      onUpdate: options?.onUpdate,
-      onDelete: options?.onDelete
-    });
-    return this;
-  }
-  dataType(column, type) {
-    this.tableStructure.columns[column.toString()].inputType = type;
-    return this;
-  }
-  maxCharacterLength(column, max) {
-    this.tableStructure.columns[column.toString()].maxLength = max;
-    return this;
-  }
-  static create(tableName, columns) {
-    return new _TableObj(tableName, columns);
-  }
-  static isTableObj(obj) {
-    return !!obj?.IS_TABLE_OBJ;
-  }
 };
 
 // src/lib/tableInfo/getTableStructure.ts
@@ -117,7 +74,7 @@ function getInputColumnInfo(table, context) {
   const metadata = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(table);
   const key = context.name ?? context;
   if (!metadata.columns.hasOwnProperty(key))
-    metadata.columns[key] = TableObj.getEmptyColumnEntry(key);
+    metadata.columns[key] = TableObjHelper.getEmptyColumnEntry(key);
   return metadata.columns[key];
 }
 function getTableStructure(table) {
@@ -151,7 +108,7 @@ var TableStructureGenerator = class {
     const tables = {};
     for (const table of this.dbInstructions.tables) {
       let structure;
-      if (TableObj.isTableObj(table)) {
+      if (TableObjHelper.isTableObj(table)) {
         structure = table.tableStructure;
         tables[table.tableName] = table.tableStructure;
       } else {
@@ -161,20 +118,25 @@ var TableStructureGenerator = class {
       }
       for (const key in structure.columns) {
         const entry = structure.columns[key];
-        entry.defaultValue = entry.inputDefaultValue === null ? this.dialect.types.null : this.dialect.formatValueToSql(entry.inputDefaultValue, entry.inputType);
-        entry.type = this.dialect.getSqlType(entry.inputType, entry);
+        entry.defaultValue = entry.inputDefaultValue === null ? this.dialect.nullType : this.dialect.formatValueToSql(entry.inputDefaultValue, entry.inputType);
+        entry.sqlType = this.dialect.getSqlType(entry.inputType, entry);
       }
     }
     return tables;
   }
 };
 
+// src/lib/typings/AllowedMigrations.ts
+var ALLOWED = "allowed";
+var USED = "allowedAndUsed";
+var NO_COLUMN = "noColumn";
+
 // src/lib/exceptions/NotAllowedException.ts
 var NotAllowedException = class extends Error {
   constructor(entries) {
     let message = "Some destructive changes need to be confirmed. To confirm, add to preMigration():\n";
     for (const entry of entries) {
-      message += `		migrations.allowMigration(${entry.version}, ${entry.tableName}, "${entry.type}");
+      message += `		migrations.allowMigration(${entry.version}, "${entry.tableName}", "${entry.type}"${entry.column != NO_COLUMN ? `, "${entry.column}"` : ""});
 `;
     }
     super(message);
@@ -188,7 +150,7 @@ var Migrations = class {
   lastUsedVersion = 0;
   migrationData = {};
   migrationDataForOldTableNames = {};
-  alwaysAllowed = {};
+  alwaysAllowed = [];
   notAllowedChanges = [];
   /**
    * Resets the migration state to its initial values.
@@ -202,20 +164,9 @@ var Migrations = class {
     this.toVersion = dbInstructions.version;
     this.migrationData = {};
     this.migrationDataForOldTableNames = {};
-    this.alwaysAllowed = dbInstructions.alwaysAllowedMigrations ?? {};
+    this.alwaysAllowed = dbInstructions.alwaysAllowedMigrations ?? [];
     this.notAllowedChanges = [];
   }
-  /**
-   * Retrieves the migration instructions for the specified table.
-   * @see getEntryFromTableName
-   *
-   * @param table - The {@link TableInput} object from which the table name will be retrieved.
-   * @return The migration instructions corresponding to the given table input.
-   */
-  getEntry(table) {
-    const tableName = this.getTableName(table);
-    return this.getEntryFromTableName(tableName);
-  }
   /**
    * Retrieves the migration instructions for the specified table.
    *
@@ -227,21 +178,11 @@ var Migrations = class {
       this.migrationData[tableName] = {
         recreate: false,
         renamedColumns: [],
-        allowedMigrations: {},
-        usedMigrations: {}
+        allowedMigrations: {}
       };
     }
     return this.migrationData[tableName];
   }
-  /**
-   * Retrieves the table name from the given table input.
-   *
-   * @param table - The {@link TableInput} object.
-   * @return The name of the table derived from either {@link TableObj} or a class.
-   */
-  getTableName(table) {
-    return TableObj.isTableObj(table) ? table.tableName : table.name;
-  }
   /**
    * Checks whether a provided version is relevant based on database version ({@link fromVersion}) and target version ({@link toVersion}).
    * Also makes sure that version checks happen in order.
@@ -251,10 +192,12 @@ var Migrations = class {
    * @throws Error if versions are not properly ordered
    */
   versionIsRelevant(version) {
-    if (version <= this.fromVersion || version > this.toVersion)
+    if (version <= this.fromVersion || version > this.toVersion) {
       return false;
-    if (version < this.lastUsedVersion)
+    }
+    if (version < this.lastUsedVersion) {
       throw new Error("Migrations in preMigration() have to be ordered by version (beginning with the lowest version).");
+    }
     this.lastUsedVersion = version;
     return true;
   }
@@ -270,20 +213,23 @@ var Migrations = class {
     for (const tableName in this.migrationData) {
       const migrationEntry = this.migrationData[tableName];
       if (migrationEntry.tableRenaming) {
-        if (migrationEntry.tableRenaming.oldName == tableName)
+        if (migrationEntry.tableRenaming.oldName == tableName) {
           return new Error(`You set table "${tableName}" to be renamed to itself!`);
-        if (migrationEntry.tableRenaming.newName != tableName)
+        }
+        if (migrationEntry.tableRenaming.newName != tableName) {
           return new Error(`You set table "${tableName}" to be renamed to a different name than the one in your structure (${migrationEntry.tableRenaming.newName})!`);
-        else if (!newTables[tableName])
-          return new Error(`You set table "${migrationEntry.tableRenaming}" migrations for "${tableName}". But "${tableName}" does not exist in your structure.`);
+        } else if (!newTables[tableName]) {
+          return new Error(`You set migrations for "${tableName}". But "${tableName}" does not exist in your structure.`);
+        }
       }
       for (const renamingData of migrationEntry.renamedColumns) {
         const oldColumnName = renamingData.oldName;
         const newColumnName = renamingData.newName;
-        if (oldColumnName == newColumnName)
+        if (oldColumnName == newColumnName) {
           return new Error(`You set column ${tableName}.${oldColumnName} to be renamed to itself!`);
-        else if (!newTables[tableName]?.columns[newColumnName])
+        } else if (!newTables[tableName]?.columns[newColumnName]) {
           return new Error(`You set column ${tableName}.${oldColumnName} to be renamed to ${tableName}.${newColumnName}. But ${tableName}.${newColumnName} does not exist in your structure.`);
+        }
       }
     }
   }
@@ -295,19 +241,25 @@ var Migrations = class {
    * @throws Error if unnecessary calls were discovered. All discovered calls are collected and thrown as one Error.
    */
   verifyAllowedMigrations() {
-    if (this.notAllowedChanges.length)
+    if (this.notAllowedChanges.length) {
       return new NotAllowedException(this.notAllowedChanges);
+    }
     let errorMsg = "";
     for (const tableName in this.migrationData) {
       const migration = this.migrationData[tableName];
       for (const type in migration.allowedMigrations) {
-        if (!migration.usedMigrations[type])
-          errorMsg += `Migration "${type}" for ${tableName} was allowed but not needed.
+        const migrationType = migration.allowedMigrations[type];
+        for (const column in migrationType) {
+          if (migrationType[column] != USED) {
+            errorMsg += `Migration "${type}" for ${tableName}${column != NO_COLUMN ? `.${column}` : ""} was allowed but not needed.
 `;
+          }
+        }
       }
     }
-    if (errorMsg)
+    if (errorMsg) {
       return new Error(errorMsg);
+    }
   }
   /**
    * Called by {@link MigrationManager} to check if a specific destructive query is allowed.
@@ -316,14 +268,18 @@ var Migrations = class {
    * @see allowMigration()
    * @param tableName - The name of the table to check the migration against.
    * @param type - The type of destructive migration being checked.
+   * @param column - The column name for which the migration is allowed. Only needed for "dropColumn", "removeForeignKey" and "alterForeignKey".
    */
-  compareWithAllowedMigration(tableName, type) {
+  compareWithAllowedMigration(tableName, type, column = NO_COLUMN) {
     const migrationEntry = this.migrationData[tableName];
-    if (!migrationEntry?.allowedMigrations[type]) {
-      if (!this.alwaysAllowed[type])
-        this.notAllowedChanges.push({ version: this.toVersion, tableName, type });
-    } else if (migrationEntry)
-      migrationEntry.usedMigrations[type] = true;
+    const allowedMigrations = migrationEntry?.allowedMigrations[type];
+    if (!allowedMigrations || !allowedMigrations[column]) {
+      if (!this.alwaysAllowed.includes(type)) {
+        this.notAllowedChanges.push({ version: this.toVersion, tableName, column, type });
+      }
+    } else if (migrationEntry) {
+      allowedMigrations[column] = USED;
+    }
   }
   /**
    * Retrieves the migration data containing instructions for data migration.
@@ -404,7 +360,7 @@ var Migrations = class {
   internalRecreate(tableName, reason) {
     const entry = this.getEntryFromTableName(tableName);
     entry.recreate = true;
-    Logger.log(`Table ${tableName} will be recreated(${reason})!`);
+    Logger.log(`Table ${tableName} will be recreated (${reason})!`);
   }
   /**
    * SqlMorpheus only allows destructive statements if it was specifically allowed in {@link DatabaseInstructions.preMigration()}.
@@ -412,15 +368,35 @@ var Migrations = class {
    * This method will be ignored if {@link version} is smaller than the current database version or higher than the target version of {@link DatabaseInstructions}.
    *
    * @param version - The target version for which the specific migration is allowed. Must be provided to make sure this method will only have an effect when specified.
-   * @param table - Either a {@link TableObj} or a class decorated with @TableClass.
-   * @param allowedMigrations - The keys representing the migrations to be allowed. Multiple migrations can be provided
+   * @param tableName - The current table name in the database at the time of the migration version.
+   * @param allowedMigration - The keys representing the migrations to be allowed.
+   * @param column - The column name for which the migration is allowed. Only needed for "dropColumn", "removeForeignKey" and "alterForeignKey".
+   *
+   * @throws Error if the provided column name is not valid for the specified migration.
    */
-  allowMigration(version, table, ...allowedMigrations) {
-    if (!this.versionIsRelevant(version))
+  allowMigration(version, tableName, allowedMigration, column) {
+    if (!this.versionIsRelevant(version)) {
       return;
-    const entry = this.getEntry(table);
-    for (const key of allowedMigrations) {
-      entry.allowedMigrations[key] = true;
+    }
+    const entry = this.getEntryFromTableName(tableName);
+    if (!entry.allowedMigrations[allowedMigration]) {
+      entry.allowedMigrations[allowedMigration] = {};
+    }
+    entry.allowedMigrations[allowedMigration][column ?? NO_COLUMN] = ALLOWED;
+    if (column) {
+      switch (allowedMigration) {
+        case "recreateTable":
+        case "dropTable":
+        case "alterPrimaryKey":
+          throw new Error(`You cannot use the ${allowedMigration} migration with a column name. Please remove the column name.`);
+      }
+    } else {
+      switch (allowedMigration) {
+        case "dropColumn":
+        case "removeForeignKey":
+        case "alterForeignKey":
+          throw new Error(`The ${allowedMigration} migration requires a column name. Please provide one.`);
+      }
     }
   }
   /**
@@ -430,19 +406,23 @@ var Migrations = class {
    * This method will be ignored if {@link version} is smaller than the current database version or higher than the target version of {@link DatabaseInstructions}.
    *
    * @param version - The target version for which the table should be renamed. Must be provided to make sure this method will only have an effect when specified.
-   * @param oldTableName - The current name in the database at the time of the migration.
-   * @param newTableName - The new table name or its equivalent input format.
+   * @param oldTableName - The current name in the database at the time of the migration version.
+   * @param newTableName - The new table name at the time of the migration version.
    */
   renameTable(version, oldTableName, newTableName) {
-    if (!this.versionIsRelevant(version))
+    if (!this.versionIsRelevant(version)) {
       return;
-    const newTableNameString = this.getTableName(newTableName);
-    const entry = this.getEntry(newTableName);
+    }
+    if (this.migrationData.hasOwnProperty(oldTableName)) {
+      this.migrationData[newTableName] = this.migrationData[oldTableName];
+      delete this.migrationData[oldTableName];
+    }
+    const entry = this.getEntryFromTableName(newTableName);
     this.migrationDataForOldTableNames[oldTableName] = entry;
-    if (!entry.tableRenaming)
-      entry.tableRenaming = { oldName: oldTableName, newName: newTableNameString };
-    else
-      entry.tableRenaming.newName = newTableNameString;
+    if (!entry.tableRenaming) {
+      entry.tableRenaming = { oldName: oldTableName, newName: newTableName };
+    } else
+      entry.tableRenaming.newName = newTableName;
   }
   /**
    * When you change the name of a column, SqlMorpheus will assume the original column was meant to be removed
@@ -451,19 +431,21 @@ var Migrations = class {
    * This method will be ignored if {@link version} is smaller than the current database version or higher than the target version of {@link DatabaseInstructions}.
    *
    * @param version - The target version for which the table should be renamed. Must be provided to make sure this method will only have an effect when specified.
-   * @param table Either a {@link TableObj} or a class decorated with @TableClass containing the column to be renamed.
+   * @param tableName - The current table name in the database at the time of the migration version.
    * @param oldColumn The current name in the database at the time of the migration.
    * @param newColumn The new name to assign to the column.
    */
-  renameColumn(version, table, oldColumn, newColumn) {
-    if (!this.versionIsRelevant(version))
+  renameColumn(version, tableName, oldColumn, newColumn) {
+    if (!this.versionIsRelevant(version)) {
       return;
-    const entry = this.getEntry(table);
+    }
+    const entry = this.getEntryFromTableName(tableName);
     const existingColumnEntry = entry.renamedColumns.find((entry2) => entry2.newName == oldColumn);
-    if (existingColumnEntry)
+    if (existingColumnEntry) {
       existingColumnEntry.newName = newColumn;
-    else
+    } else {
       entry.renamedColumns.push({ oldName: oldColumn, newName: newColumn });
+    }
   }
   /**
    * Should not be needed most of the time.
@@ -472,682 +454,170 @@ var Migrations = class {
    * This method will be ignored if {@link version} is smaller than the current database version or higher than the target version of {@link DatabaseInstructions}.
    *
    * @param version - The target version for which the table should be renamed. Must be provided to make sure this method will only have an effect when specified.
-   * @param table Either a {@link TableObj} or a class decorated with @TableClass.
+   * @param tableName - The current table name in the database at the time of the migration version.
    */
-  recreateTable(version, table) {
-    if (!this.versionIsRelevant(version))
+  recreateTable(version, tableName) {
+    if (!this.versionIsRelevant(version)) {
       return;
-    const entry = this.getEntry(table);
+    }
+    const entry = this.getEntryFromTableName(tableName);
     entry.recreate = true;
-    Logger.log(`Table ${this.getTableName(table)} will be recreated!`);
-    this.allowMigration(version, table, "recreateTable");
+    Logger.log(`Table ${tableName} will be recreated!`);
+    this.allowMigration(version, tableName, "recreateTable");
   }
 };
 
-// src/lib/MigrationManager.ts
-var MigrationManager = class {
-  migrations = new Migrations();
-  newTables = {};
-  /**
-   * Table names that currently exist in the database
-   * Note: If tables are set to be renamed, then names in this array will be corrected to their future name.
-   */
-  existingTables = [];
-  dialect;
-  constructor(dialect) {
-    this.dialect = dialect;
+// src/lib/dialects/DefaultSql.ts
+import escapeString from "escape-sql-string";
+var MIGRATION_DATA_TABLE_NAME = "__sqlmorpheus_migrations";
+var DefaultSql = class {
+  db;
+  canRecreateTable = false;
+  canAlterColumnStructure = false;
+  canAlterForeignKeys = false;
+  canAlterPrimaryKey = false;
+  types = {
+    text: "TEXT",
+    string: "TEXT",
+    number: "INTEGER",
+    bigint: "BIGINT",
+    boolean: "BOOLEAN",
+    date: "DATE",
+    time: "TIME",
+    dateTime: "DATETIME"
+  };
+  nullType = "NULL";
+  constructor(db) {
+    this.db = db;
   }
   /**
-   * 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.
+   * Formats a given value to a SQL-equivalent string based on the provided data type.
    *
-   * @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.
+   * @param value - The value to be formatted.
+   * @param type - The data type of the value. Either determined through typeof or {@link TableStructure} setting
+   * @return A string representation of the value formatted for SQL.
    */
-  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()).map((oldTableName) => this.migrations.getNewestTableName(oldTableName));
-      [
-        this.renameTables(),
-        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}`;
+  formatValueToSql(value, type) {
+    function toDate(value2) {
+      return value2 instanceof Date ? value2 : new Date(value2);
     }
-    const foreignKeyOnQuery = this.dialect.changeForeignKeysState(true);
-    changes.up += `
-
-${foreignKeyOnQuery}`;
-    changes.down += `
-
-${foreignKeyOnQuery}`;
-    if (fromVersion != 0) {
-      const exception = this.migrations.verifyRenamingTasks(this.newTables) ?? this.migrations.verifyAllowedMigrations();
-      if (exception) {
-        Logger.debug(`
-Canceled changes:
-${changes.up}
-`);
-        if (dbInstructions.throwIfNotAllowed)
-          throw exception;
-        else {
-          console.error(exception.message);
-          return null;
-        }
-      }
+    switch (type) {
+      case "text":
+      case "string":
+        return `'${value}'`;
+      case "time":
+        return `'${toDate(value).toISOString().slice(11, 19)}'`;
+      case "date":
+        return `'${toDate(value).toISOString().slice(0, 10)}'`;
+      case "dateTime":
+        return `'${toDate(value).toISOString().slice(0, 19).replace("T", " ")}'`;
+      default:
+        return value.toString();
     }
-    return {
-      fromVersion,
-      toVersion,
-      changes
-    };
   }
-  renameTables() {
-    const changes = {
-      up: "\n\n-- Rename tables\n",
-      down: "\n\n-- Rename tables\n"
-    };
-    const data = this.migrations.getMigrationData();
-    for (const tableName in data) {
-      const migrationEntry = data[tableName];
-      if (migrationEntry.tableRenaming) {
-        Logger.log(`Table "${migrationEntry.tableRenaming.oldName}" will be renamed to "${tableName}"!`);
-        changes.up += this.dialect.renameTable(migrationEntry.tableRenaming.oldName, tableName);
-        changes.down += this.dialect.renameTable(tableName, migrationEntry.tableRenaming.oldName);
-      }
-    }
-    return changes;
+  formatIdentifier(identifier) {
+    return identifier;
+  }
+  getSqlType(dataType, _) {
+    return this.types[dataType];
   }
   /**
-   * 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.
+   * Changes the column type and the default value of a column in a specified table.
+   * Is only used if {@link canAlterColumnStructure} is true.
    *
-   * @return {Promise<SqlChanges>} A promise that resolves to an object containing `up` and `down` SQL
-   * change statements for migrating the database schema.
+   * @param tableName - The name of the table containing the column to be altered.
+   * @param columnName - The name of the column to be altered.
+   * @param sqlType - The new data type (specific to the SQL dialect) for the column.
+   * @param defaultValue - The new default value for the column.
+   * @return The SQL statement as a string.
    */
-  async createAndDropTables() {
-    let changes = {
-      up: "\n\n-- Create and drop tables\n",
-      down: "\n\n-- Create and drop 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.compareWithAllowedMigration(tableName, "dropTable");
-        if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
-          this.migrations.compareWithAllowedMigration(tableName, "continueWithoutRollback");
-        const dbTableName = this.migrations.getOldTableName(tableName);
-        changes.up += `${this.dialect.dropTable(tableName)}
-`;
-        changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(tableName, await this.dialect.getColumnInformation(dbTableName), await this.dialect.getForeignKeys(dbTableName)) : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
-      }
-    }
-    return changes;
+  alterColumnStructure(tableName, columnName, sqlType, defaultValue) {
+    throw new Error("Altering column structure is not supported. Recreate the table instead!");
   }
   /**
-   * Generates an SQL string to create a table with the specified schema.
+   * Statement to add a foreign key to a specified table.
+   * Is only used if {@link canAlterForeignKeys} is true.
    *
-   * @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 fromTableName - The name of the table to which the foreign key will be added.
+   * @param foreignKey - The foreign key definition to be added, see {@link foreignKey()}.
+   * @return The SQL statement as a string.
    */
-  createTableSql(tableName, columns, foreignKeys) {
-    const queryLines = [];
-    for (const key in columns) {
-      const columnInfo = columns[key];
-      queryLines.push(this.dialect.columnDefinition(columnInfo.name, columnInfo.type, columnInfo.isPrimaryKey, columnInfo.defaultValue));
-    }
-    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);
+  addForeignKey(fromTableName, foreignKey) {
+    throw new Error("Adding foreign keys is not supported!");
   }
   /**
-   * Checks if the specified table does not exist in the list of existing tables.
+   * Statement to remove a foreign key from a specified table.
+   * Is only used if {@link canAlterForeignKeys} is true.
    *
-   * @param tableName - The name of the table to check.
-   * @return Returns true if the table does not exist, otherwise false.
+   * @param tableName - The name of the table to which the foreign key will be added.
+   * @param foreignKeyName - The name of the foreign key definition.
+   * @return The SQL statement as a string.
    */
-  tableDoesNotExists(tableName) {
-    return this.existingTables.indexOf(tableName) == -1;
+  removeForeignKey(tableName, foreignKeyName) {
+    throw new Error("Foreign key removal is not supported!");
   }
   /**
-   * 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.
+   * Statement to add a primary key to the specified table.
+   * Is only used if {@link canAlterPrimaryKey} is true.
+   *
+   * @param tableName - The name of the table to which the primary key will be added.
+   * @param columnName - The name of the column that will be set as the primary key.
+   * @return The SQL statement as a string.
    */
-  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.compareWithAllowedMigration(tableName, "recreateTable");
-      if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
-        this.migrations.compareWithAllowedMigration(tableName, "continueWithoutRollback");
-      const oldColumnList = await this.dialect.getColumnInformation(this.migrations.getOldTableName(tableName));
-      const newColumnList = this.newTables[tableName].columns;
-      const moveableColumns = [];
-      for (const key in newColumnList) {
-        if (oldColumnList.hasOwnProperty(key))
-          moveableColumns.push(newColumnList[key].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 + "\n\n";
-      const dbTableName = this.migrations.getOldTableName(tableName);
-      changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(backupTableName, await this.dialect.getColumnInformation(dbTableName), await this.dialect.getForeignKeys(dbTableName)) + "\n" + moveDataQuery : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
-    }
-    return changes;
+  addPrimaryKey(tableName, columnName) {
+    throw new Error("Adding foreign keys is not supported!");
   }
   /**
-   * Migrates foreign key constraints for all defined tables.
+   * Statement to remove a primary key from the specified table.
+   * Is only used if {@link canAlterPrimaryKey} is true.
+   *
+   * @param tableName - The name of the table to which the primary key will be added.
+   * @param columnName - The name of the column that will be set as the primary key.
+   * @return The SQL statement as a string.
    */
-  async migrateForeignKeys() {
-    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(this.migrations.getOldTableName(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.fromTable}.${oldForeignKey.fromColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} will be removed!`);
-          this.migrations.compareWithAllowedMigration(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.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
-            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.fromTable}.${oldForeignKey.fromColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} will be changed!`);
-            this.migrations.compareWithAllowedMigration(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.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
-              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.fromTable}.${newForeignKey.fromColumn} to ${newForeignKey.toTable}.${newForeignKey.toColumn} will be added!`);
-          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.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
-            break;
-          }
-        }
-      }
-    }
-    return changes;
+  removePrimaryKey(tableName, columnName) {
+    throw new Error("Foreign key removal is not supported!");
   }
   /**
-   * 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
+   * Constructs a SQL FOREIGN KEY constraint clause.
+   * Used in combination with {@link addForeignKey} or {@link createTable}
+   *
+   * @param column - The name of the column in the current table to apply the foreign key constraint.
+   * @param foreignTable - The name of the referenced table.
+   * @param foreignColumn - The name of the referenced column in the foreign table.
+   * @param onUpdate - Optional action to specify the behavior on update (e.g., CASCADE, SET NULL).
+   * @param onDelete - Optional action to specify the behavior on delete (e.g., CASCADE, SET NULL).
+   * @return The SQL string representing the foreign key constraint.
    */
-  async migrateColumns() {
-    const changes = {
-      up: "\n\n-- Migrate columns\n",
-      down: "\n\n-- Migrate columns\n"
-    };
-    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(this.migrations.getOldTableName(tableName));
-      const oldPrimaryKey = this.dialect.canInspectPrimaryKey ? this.getPrimaryKeyColumn(oldColumnList) : false;
-      const oldColumnNewNameIndex = {};
-      for (const key in oldColumnList) {
-        oldColumnNewNameIndex[this.migrations.getNewestColumnName(tableName, key)] = oldColumnList[key];
-      }
-      const newColumnList = newTableDefinition.columns;
-      const newPrimaryKey = newTableDefinition.primaryKey;
-      if (this.dialect.canInspectPrimaryKey && oldPrimaryKey != newPrimaryKey) {
-        Logger.log(`Primary key in ${tableName} will be changed from ${oldPrimaryKey} to ${newPrimaryKey}!`);
-        this.migrations.compareWithAllowedMigration(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.internalRecreate(newTableDefinition.table, "Dialect does not support altering primary keys");
-        continue;
-      }
-      const renamedColumns = this.migrations.getMigrationData()[tableName]?.renamedColumns;
-      for (const key in newColumnList) {
-        const newColumn = newColumnList[key];
-        const oldColumn = oldColumnNewNameIndex[newColumn.name];
-        const willBeRenamed = renamedColumns?.find((entry) => entry.newName);
-        if (willBeRenamed)
-          continue;
-        if (oldColumn == void 0) {
-          changes.up += this.dialect.createColumn(tableName, this.dialect.columnDefinition(newColumn.name, newColumn.type, newColumn.isPrimaryKey, newColumn.defaultValue)) + "\n";
-          changes.down += this.dialect.dropColumn(tableName, newColumn.name) + "\n";
-        } else if (newColumn.type != oldColumn.type || newColumn.defaultValue != oldColumn.defaultValue) {
-          this.migrations.internalRecreate(newTableDefinition.table, "Table structure was changed");
-        }
-      }
-      for (const key in oldColumnList) {
-        const oldColumn = oldColumnList[key];
-        const newColumn = newColumnList[this.migrations.getNewestColumnName(tableName, oldColumn.name)];
-        if (newColumn == void 0) {
-          this.migrations.compareWithAllowedMigration(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.isPrimaryKey, oldColumn.defaultValue)) + "\n";
-        }
-      }
-    }
-    return changes;
+  foreignKey(column, foreignTable, foreignColumn, onUpdate, onDelete) {
+    let query = `FOREIGN KEY (${this.formatIdentifier(column)}) REFERENCES ${this.formatIdentifier(foreignTable)} (${this.formatIdentifier(foreignColumn)})`;
+    if (onUpdate)
+      query += ` ON UPDATE ${onUpdate}`;
+    if (onDelete)
+      query += ` ON DELETE ${onDelete}`;
+    return query;
   }
   /**
-   * Retrieves the name of the primary key column from a list of column information.
+   * Statement to create a table if it does not already exist.
    *
-   * @param columnInfoEntries - An array of ColumnInfo objects containing details about each column.
-   * @return The name of the primary key column if found; otherwise, undefined.
+   * @param tableName - The name of the table to be created.
+   * @param entries - An array containing the column definitions for the table.
+   * @return The SQL statement as a string.
    */
-  getPrimaryKeyColumn(columnInfoEntries) {
-    for (const key in columnInfoEntries) {
-      const columnInfo = columnInfoEntries[key];
-      if (columnInfo.isPrimaryKey)
-        return columnInfo.name;
-    }
+  createTable(tableName, entries) {
+    return `CREATE TABLE IF NOT EXISTS ${this.formatIdentifier(tableName)} (
+	${entries.join(",\n	")}
+);`;
   }
   /**
-   * 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) => {
-        Logger.log(`Column ${tableName}.${oldColumnName} will be renamed to ${tableName}.${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 } 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 });
-  }
-  /**
-   * Creates migration history files for upgrading and downgrading database schemas.
-   *
-   * @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`.
-   */
-  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}`);
-    return 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.
-   *
-   * @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.
-   */
-  getUpMigration(toVersion) {
-    return readFileSync(`${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion}.sql`, { encoding: "utf-8" });
-  }
-  /**
-   * 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.
-   */
-  getDownMigration(version) {
-    return readFileSync(`${this.migrationsPath}/${FILENAME_DOWN_PREFIX}${version}.sql`, { encoding: "utf-8" });
-  }
-};
-
-// src/lib/tableInfo/decorators/TableClass.ts
-import "polyfill-symbol-metadata";
-function TableClass(tableName, primaryKey) {
-  return (table, context) => {
-    const tableStructure = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(table);
-    tableStructure.primaryKey = primaryKey?.toString();
-    tableStructure.table = tableName;
-    if (tableStructure.foreignKeys) {
-      for (const foreignKey of tableStructure.foreignKeys) {
-        foreignKey.fromTable = tableName;
-        if (foreignKey.toTable == table.name)
-          foreignKey.toTable = tableName;
-      }
-    }
-    const obj = new table();
-    for (const key in obj) {
-      const value = obj[key];
-      const existingEntry = tableStructure.columns[key];
-      const defaultEntry = TableObj.getColumnEntry(key, value);
-      if (!defaultEntry)
-        continue;
-      if (key == primaryKey)
-        defaultEntry.isPrimaryKey = true;
-      tableStructure.columns[key] = {
-        ...defaultEntry,
-        ...existingEntry
-      };
-    }
-    Object.defineProperty(table, "name", { value: tableName, writable: false });
-  };
-}
-
-// src/lib/tableInfo/decorators/DataType.ts
-import "polyfill-symbol-metadata";
-function DataType(type) {
-  return (table, context) => {
-    const entry = getInputColumnInfo(table, context);
-    entry.inputType = type;
-  };
-}
-
-// src/lib/tableInfo/decorators/ForeignKey.ts
-import "polyfill-symbol-metadata";
-function ForeignKey(toTable, toColumn, options) {
-  return (table, context) => {
-    const metadata = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(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: options?.onDelete,
-      onUpdate: options?.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;
-  types = {
-    string: "TEXT",
-    number: "INTEGER",
-    bigint: "BIGINT",
-    boolean: "BOOLEAN",
-    date: "DATE",
-    time: "TIME",
-    dateTime: "DATETIME",
-    null: "NULL"
-  };
-  constructor(db) {
-    this.db = db;
-  }
-  /**
-   * Formats a given value to a SQL-equivalent string based on the provided data type.
-   *
-   * @param value - The value to be formatted.
-   * @param type - The data type of the value. Either determined through typeof or {@link TableStructure} setting
-   * @return A string representation of the value formatted for SQL.
-   */
-  formatValueToSql(value, type) {
-    function toDate(value2) {
-      return value2 instanceof Date ? value2 : new Date(value2);
-    }
-    switch (type) {
-      case "string":
-        return `"${value}"`;
-      case "time":
-        return `"${toDate(value).toISOString().slice(11, 19)}"`;
-      case "date":
-        return `"${toDate(value).toISOString().slice(0, 10)}"`;
-      case "dateTime":
-        return `"${toDate(value).toISOString().slice(0, 19).replace("T", " ")}"`;
-      default:
-        return value.toString();
-    }
-  }
-  getSqlType(dataType, _) {
-    return this.types[dataType];
-  }
-  /**
-   * Statement to enable / disable foreign keys in the database.
-   * Is dialect specific.
-   *
-   * @param enabled - A boolean indicating whether to enable or disable foreign key constraints.
-   * @return The SQL statement as a string.
-   */
-  changeForeignKeysState(enabled) {
-    return "";
-  }
-  /**
-   * Statement to add a foreign key to a specified table.
-   * Is only used if {@link canAlterForeignKeys} is true.
-   *
-   * @param fromTableName - The name of the table to which the foreign key will be added.
-   * @param foreignKey - The foreign key definition to be added, see {@link foreignKey()}.
-   * @return The SQL statement as a string.
-   */
-  addForeignKey(fromTableName, foreignKey) {
-    throw new Error("Adding foreign keys is not supported!");
-  }
-  /**
-   * Statement to remove a foreign key from a specified table.
-   * Is only used if {@link canAlterForeignKeys} is true.
-   *
-   * @param tableName - The name of the table to which the foreign key will be added.
-   * @param foreignKeyName - The name of the foreign key definition.
-   * @return The SQL statement as a string.
-   */
-  removeForeignKey(tableName, foreignKeyName) {
-    throw new Error("Foreign key removal is not supported!");
-  }
-  /**
-   * Statement to add a primary key to the specified table.
-   * Is only used if {@link canAlterPrimaryKey} is true.
-   *
-   * @param tableName - The name of the table to which the primary key will be added.
-   * @param columnName - The name of the column that will be set as the primary key.
-   * @return The SQL statement as a string.
-   */
-  addPrimaryKey(tableName, columnName) {
-    throw new Error("Adding foreign keys is not supported!");
-  }
-  /**
-   * Statement to remove a primary key from the specified table.
-   * Is only used if {@link canAlterPrimaryKey} is true.
-   *
-   * @param tableName - The name of the table to which the primary key will be added.
-   * @param columnName - The name of the column that will be set as the primary key.
-   * @return The SQL statement as a string.
-   */
-  removePrimaryKey(tableName, columnName) {
-    throw new Error("Foreign key removal is not supported!");
-  }
-  /**
-   * Constructs a SQL FOREIGN KEY constraint clause.
-   * Used in combination with {@link addForeignKey} or {@link createTable}
-   *
-   * @param column - The name of the column in the current table to apply the foreign key constraint.
-   * @param foreignTable - The name of the referenced table.
-   * @param foreignColumn - The name of the referenced column in the foreign table.
-   * @param onUpdate - Optional action to specify the behavior on update (e.g., CASCADE, SET NULL).
-   * @param onDelete - Optional action to specify the behavior on delete (e.g., CASCADE, SET NULL).
-   * @return The SQL string representing the foreign key constraint.
-   */
-  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;
-  }
-  /**
-   * Statement to create a table if it does not already exist.
-   *
-   * @param tableName - The name of the table to be created.
-   * @param entries - An array containing the column definitions for the table.
-   * @return The SQL statement as a string.
-   */
-  createTable(tableName, entries) {
-    return `CREATE TABLE IF NOT EXISTS ${tableName}  (
-	${entries.join(",\n	")}
-);`;
-  }
-  /**
-   * Statement to rename a table.
-   *
-   * @param tableName - The name of the existing table to be renamed.
-   * @param newTableName - The new name for the table.
-   * @return The SQL statement as a string.
+   * Statement to rename a table.
+   *
+   * @param tableName - The name of the existing table to be renamed.
+   * @param newTableName - The new name for the table.
+   * @return The SQL statement as a string.
    */
   renameTable(tableName, newTableName) {
-    return `ALTER TABLE ${tableName} RENAME TO ${newTableName};`;
+    return `ALTER TABLE ${this.formatIdentifier(tableName)} RENAME TO ${this.formatIdentifier(newTableName)};`;
   }
   /**
    * Statement to drop a table if it exists.
@@ -1156,7 +626,10 @@ var DefaultSql = class {
    * @return The SQL statement as a string.
    */
   dropTable(tableName) {
-    return `DROP TABLE IF EXISTS ${tableName};`;
+    return `DROP TABLE IF EXISTS ${this.formatIdentifier(tableName)};`;
+  }
+  recreateTable(tableName, entries) {
+    return `DROP TABLE IF EXISTS ${this.formatIdentifier(tableName)}; ${this.createTable(tableName, entries)}`;
   }
   /**
    * Constructs a SQL column definition based on the provided parameters.
@@ -1168,7 +641,7 @@ var DefaultSql = class {
    * @return The constructed SQL column definition string.
    */
   columnDefinition(columnName, type, isPrimaryKey, defaultValue) {
-    const query = `${columnName} ${type}${defaultValue ? ` DEFAULT ${defaultValue}` : ""}`;
+    const query = `${this.formatIdentifier(columnName)} ${type}${defaultValue ? ` DEFAULT ${defaultValue}` : ""}`;
     return isPrimaryKey ? `${query} PRIMARY KEY` : query;
   }
   /**
@@ -1179,7 +652,7 @@ var DefaultSql = class {
    * @return The SQL statement as a string.
    */
   createColumn(columnTable, entry) {
-    return `ALTER TABLE ${columnTable} ADD ${entry};`;
+    return `ALTER TABLE ${this.formatIdentifier(columnTable)} ADD ${entry};`;
   }
   /**
    * Statement to rename a column in an existing table.
@@ -1190,7 +663,7 @@ var DefaultSql = class {
    * @return The SQL statement as a string.
    */
   renameColumn(tableName, oldColumnName, newColumnName) {
-    return `ALTER TABLE ${tableName} RENAME COLUMN ${oldColumnName} TO ${newColumnName};`;
+    return `ALTER TABLE ${this.formatIdentifier(tableName)} RENAME COLUMN ${this.formatIdentifier(oldColumnName)} TO ${this.formatIdentifier(newColumnName)};`;
   }
   /**
    * Statement to drop a column from a specified table.
@@ -1200,7 +673,7 @@ var DefaultSql = class {
    * @return The SQL statement as a string.
    */
   dropColumn(tableName, columnName) {
-    return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
+    return `ALTER TABLE ${this.formatIdentifier(tableName)} DROP COLUMN ${this.formatIdentifier(columnName)};`;
   }
   /**
    * Statement to return data from a table.
@@ -1208,123 +681,710 @@ var DefaultSql = class {
    * @param tableName - The name of the database table to select data from.
    * @param select - An array of column names to include in the SELECT clause.
    * @param where - An optional condition.
+   * @param orderBy - Optional. the column to sort by
    * @return The SQL statement as a string.
    */
-  select(tableName, select, where) {
-    let query = `SELECT ${select.join(",")} FROM ${tableName}`;
-    if (where)
+  select(tableName, select, where, orderBy) {
+    let query = `SELECT ${select.map((k) => this.formatIdentifier(k)).join(",")} FROM ${this.formatIdentifier(tableName)}`;
+    if (where) {
       query += ` WHERE ${where}`;
+    }
+    if (orderBy) {
+      query += ` ORDER BY ${orderBy}`;
+    }
     return `${query};`;
   }
   /**
-   * Statement to insert data into a table.
+   * Statement to insert data into a table.
+   *
+   * @param tableName - The name of the table where the data will be inserted.
+   * @param content - The value query. See {@link insertValues()}.
+   * @return The SQL statement as a string.
+   */
+  insert(tableName, content) {
+    return `INSERT INTO ${this.formatIdentifier(tableName)} ${content};`;
+  }
+  /**
+   * A SQL insert query string. See {@link insert()}.
+   *
+   * @param keys - An array of column names to be used in the query.
+   * @param [valueString] - An optional preformatted value string to be included in the query.
+   * If not provided, the method generates a default placeholder string with "?" for each key.
+   * @return The SQL statement as a string.
+   */
+  insertValues(keys, valueString) {
+    return `(${keys.map((k) => this.formatIdentifier(k)).join(",")}) ${valueString ?? `VALUES (${keys.map(() => "?").join(",")})`}`;
+  }
+  /**
+   * Returns a SQL query string to create a migration table.
+   * The table is used to store migration data, specifically the version of the migration.
+   *
+   * @return The SQL query string for creating the migration table.
+   */
+  migrationTableQuery() {
+    return this.createTable(MIGRATION_DATA_TABLE_NAME, [
+      this.columnDefinition("fromVersion", this.getSqlType("number"), false, "0"),
+      this.columnDefinition("toVersion", this.getSqlType("number"), true, "0"),
+      this.columnDefinition("upChanges", this.getSqlType("text"), false),
+      this.columnDefinition("downChanges", this.getSqlType("text"), false)
+    ]);
+  }
+  /**
+   * Ensures that the migration table exists in the database.
+   * If the table does not exist, it creates the table using the defined migration table query.
+   *
+   * @return A promise that resolves when the migration table is created successfully.
+   */
+  async createMigrationTableIfNeeded() {
+    await this.db.runTransaction(this.migrationTableQuery());
+  }
+  /**
+   * Retrieves the current version from the migration data table.
+   *
+   * @return A promise that resolves to the current version number. Returns 0 if no version is found.
+   */
+  async getVersion() {
+    await this.createMigrationTableIfNeeded();
+    const query = this.select(MIGRATION_DATA_TABLE_NAME, ["toVersion"], void 0, `${this.formatIdentifier("toVersion")} DESC`);
+    const data = await this.db.runReadStatement(query);
+    return data.length ? data[0].toVersion : 0;
+  }
+  /**
+   * Updates the migration version in the database. If the version entry does not exist, it inserts a new one;
+   * if it exists, it updates the version to the specified value.
+   *
+   * @param toVersion - The new migration version to set in the database.
+   * @return A promise that resolves when the operation is complete.
+   */
+  async rollbackHistory(toVersion) {
+    const query = `${this.migrationTableQuery()}; DELETE FROM ${MIGRATION_DATA_TABLE_NAME} WHERE toVersion > ${toVersion};`;
+    await this.db.runTransaction(query);
+  }
+  async getChanges(version) {
+    await this.createMigrationTableIfNeeded();
+    const query = this.select(MIGRATION_DATA_TABLE_NAME, ["fromVersion", "upChanges", "downChanges"], `toVersion = ${version}`);
+    const data = await this.db.runReadStatement(query);
+    return data ? { up: data[0].upChanges, down: data[0].downChanges, fromVersion: data[0].fromVersion } : null;
+  }
+  async hasChanges(version) {
+    await this.createMigrationTableIfNeeded();
+    const query = this.select(MIGRATION_DATA_TABLE_NAME, ["toVersion"], `${this.formatIdentifier("toVersion")} = ${version}`);
+    const data = await this.db.runReadStatement(query);
+    return !!data.length;
+  }
+  /**
+   * Saves the change history to the SQLMorpheus table in the database
+   * Since we save SQL queries in the database, we need to make sure that they are properly escaped.
+   * @param fromVersion
+   * @param toVersion
+   * @param changes
+   */
+  async setChanges(fromVersion, toVersion, changes) {
+    const downChanges = escapeString(changes.down);
+    const upChanges = escapeString(changes.up);
+    const query = `${this.migrationTableQuery()} ${await this.hasChanges(toVersion) ? `UPDATE ${MIGRATION_DATA_TABLE_NAME}
+				SET
+				    ${this.formatIdentifier("fromVersion")} = '${fromVersion}',
+			   	    ${this.formatIdentifier("upChanges")} = ${upChanges},
+			   	    ${this.formatIdentifier("downChanges")} = ${downChanges}
+			   	WHERE ${this.formatIdentifier("toVersion")} = '${toVersion}';` : `INSERT INTO ${MIGRATION_DATA_TABLE_NAME} (
+					${this.formatIdentifier("fromVersion")},
+    				${this.formatIdentifier("toVersion")},
+					${this.formatIdentifier("upChanges")},
+					${this.formatIdentifier("downChanges")}
+				)
+				VALUES ('${fromVersion}', '${toVersion}', ${upChanges}, ${downChanges})`}`;
+    await this.db.runTransaction(query);
+  }
+};
+
+// src/lib/MigrationManager.ts
+var MigrationManager = class {
+  migrations = new Migrations();
+  newTables = {};
+  /**
+   * Table names that currently exist in the database
+   * Note: If tables are set to be renamed, then names in this array will be corrected to their future name.
+   */
+  existingTables = [];
+  dialect;
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  /**
+   * 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.
+   */
+  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 changes = {
+      up: "",
+      down: ""
+    };
+    this.migrations.reset(dbInstructions, fromVersion);
+    const preSQL = dbInstructions.preMigration?.(
+      this.migrations,
+      this.dialect.db,
+      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()).filter((oldTableName) => oldTableName != MIGRATION_DATA_TABLE_NAME).map((oldTableName) => this.migrations.getNewestTableName(oldTableName));
+      [
+        this.renameTables(),
+        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?.(this.dialect.db, fromVersion, toVersion);
+    if (postSql) {
+      changes.up += `
+
+-- Custom SQL from postMigration()
+${postSql.up}`;
+      changes.down += `
+
+-- Custom SQL from postMigration()
+${postSql.down}`;
+    }
+    if (fromVersion != 0) {
+      const exception = this.migrations.verifyRenamingTasks(this.newTables) ?? this.migrations.verifyAllowedMigrations();
+      if (exception) {
+        Logger.debug(`
+Canceled changes:
+${changes.up}
+`);
+        if (!dbInstructions.doNotThrowIfNotAllowed)
+          throw exception;
+        else {
+          console.error(exception.message);
+          return null;
+        }
+      }
+    }
+    return {
+      fromVersion,
+      toVersion,
+      changes
+    };
+  }
+  renameTables() {
+    const changes = {
+      up: "\n\n-- Rename tables\n",
+      down: "\n\n-- Rename tables\n"
+    };
+    const data = this.migrations.getMigrationData();
+    for (const tableName in data) {
+      const migrationEntry = data[tableName];
+      if (migrationEntry.tableRenaming) {
+        Logger.log(`Table "${migrationEntry.tableRenaming.oldName}" will be renamed to "${tableName}"!`);
+        changes.up += this.dialect.renameTable(migrationEntry.tableRenaming.oldName, tableName);
+        changes.down += this.dialect.renameTable(tableName, migrationEntry.tableRenaming.oldName);
+      }
+    }
+    return changes;
+  }
+  /**
+   * 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.
+   */
+  async createAndDropTables() {
+    let changes = {
+      up: "\n\n-- Create and drop tables\n",
+      down: "\n\n-- Create and drop 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.compareWithAllowedMigration(tableName, "dropTable");
+        const dbTableName = this.migrations.getOldTableName(tableName);
+        changes.up += `${this.dialect.dropTable(tableName)}
+`;
+        changes.down += this.createTableSql(tableName, await this.dialect.getColumnInformation(dbTableName), await this.dialect.getForeignKeys(dbTableName));
+      }
+    }
+    return changes;
+  }
+  /**
+   * Generates an SQL string to create a table with the specified schema.
+   *
+   * @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.
+   */
+  createTableSql(tableName, columns, foreignKeys) {
+    const queryLines = [];
+    for (const key in columns) {
+      const columnInfo = columns[key];
+      queryLines.push(this.dialect.columnDefinition(columnInfo.name, columnInfo.sqlType, columnInfo.isPrimaryKey, columnInfo.defaultValue));
+    }
+    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);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+      }
+      if (!this.dialect.canRecreateTable) {
+        throw new Error("SQL dialect does not support recreating tables!");
+      }
+      this.migrations.compareWithAllowedMigration(tableName, "recreateTable");
+      const oldColumnList = await this.dialect.getColumnInformation(this.migrations.getOldTableName(tableName));
+      const newColumnList = this.newTables[tableName].columns;
+      const moveableColumns = [];
+      for (const key in newColumnList) {
+        if (oldColumnList.hasOwnProperty(key))
+          moveableColumns.push(newColumnList[key].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 + "\n\n";
+      const dbTableName = this.migrations.getOldTableName(tableName);
+      changes.down += this.createTableSql(backupTableName, await this.dialect.getColumnInformation(dbTableName), await this.dialect.getForeignKeys(dbTableName)) + "\n" + moveDataQuery;
+    }
+    return changes;
+  }
+  /**
+   * Migrates foreign key constraints for all defined tables.
+   */
+  async migrateForeignKeys() {
+    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(this.migrations.getOldTableName(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.fromTable}.${oldForeignKey.fromColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} will be removed!`);
+          this.migrations.compareWithAllowedMigration(tableName, "removeForeignKey", oldForeignKey.fromColumn);
+          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.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
+            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.fromTable}.${oldForeignKey.fromColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} will be changed!`);
+            this.migrations.compareWithAllowedMigration(tableName, "alterForeignKey", oldForeignKey.fromColumn);
+            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.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
+              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.fromTable}.${newForeignKey.fromColumn} to ${newForeignKey.toTable}.${newForeignKey.toColumn} will be added!`);
+          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.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
+            break;
+          }
+        }
+      }
+    }
+    return changes;
+  }
+  /**
+   * 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.newTables) {
+      if (this.migrations.willBeRecreated(tableName) || this.tableDoesNotExists(tableName))
+        continue;
+      const newTableDefinition = this.newTables[tableName];
+      const oldColumnList = await this.dialect.getColumnInformation(this.migrations.getOldTableName(tableName));
+      const oldPrimaryKey = this.getPrimaryKeyColumn(oldColumnList);
+      const oldColumnNewNameIndex = {};
+      for (const key in oldColumnList) {
+        oldColumnNewNameIndex[this.migrations.getNewestColumnName(tableName, key)] = oldColumnList[key];
+      }
+      const newColumnList = newTableDefinition.columns;
+      const newPrimaryKey = newTableDefinition.primaryKey;
+      if (oldPrimaryKey != newPrimaryKey) {
+        Logger.log(`Primary key in ${tableName} will be changed from ${oldPrimaryKey} to ${newPrimaryKey}!`);
+        this.migrations.compareWithAllowedMigration(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.internalRecreate(newTableDefinition.table, "Dialect does not support altering primary keys");
+        continue;
+      }
+      const renamedColumns = this.migrations.getMigrationData()[tableName]?.renamedColumns;
+      for (const key in newColumnList) {
+        const newColumn = newColumnList[key];
+        const oldColumn = oldColumnNewNameIndex[newColumn.name];
+        const willBeRenamed = renamedColumns?.find((entry) => entry.newName);
+        if (willBeRenamed)
+          continue;
+        if (oldColumn == void 0) {
+          changes.up += this.dialect.createColumn(tableName, this.dialect.columnDefinition(newColumn.name, newColumn.sqlType, newColumn.isPrimaryKey, newColumn.defaultValue)) + "\n";
+          changes.down += this.dialect.dropColumn(tableName, newColumn.name) + "\n";
+        } else if (this.dialect.canAlterColumnStructure) {
+          changes.up += this.dialect.alterColumnStructure(tableName, newColumn.name, newColumn.sqlType, newColumn.defaultValue);
+          changes.down += this.dialect.alterColumnStructure(tableName, oldColumn.name, oldColumn.sqlType, oldColumn.defaultValue);
+        } else if (newColumn.sqlType != oldColumn.sqlType || newColumn.defaultValue != oldColumn.defaultValue) {
+          this.migrations.internalRecreate(newTableDefinition.table, "Table structure was changed");
+        }
+      }
+      for (const key in oldColumnList) {
+        const oldColumn = oldColumnList[key];
+        const newColumn = newColumnList[this.migrations.getNewestColumnName(tableName, oldColumn.name)];
+        if (newColumn == void 0) {
+          this.migrations.compareWithAllowedMigration(tableName, "dropColumn", oldColumn.name);
+          changes.up += this.dialect.dropColumn(tableName, oldColumn.name) + "\n";
+          changes.down += this.dialect.createColumn(tableName, this.dialect.columnDefinition(oldColumn.name, oldColumn.sqlType, oldColumn.isPrimaryKey, oldColumn.defaultValue)) + "\n";
+        }
+      }
+    }
+    return changes;
+  }
+  /**
+   * Retrieves the name of the primary key column from a list of column information.
    *
-   * @param tableName - The name of the table where the data will be inserted.
-   * @param content - The value query. See {@link insertValues()}.
-   * @return The SQL statement as a string.
+   * @param columnInfoEntries - An array of ColumnInfo objects containing details about each column.
+   * @return The name of the primary key column if found; otherwise, undefined.
    */
-  insert(tableName, content) {
-    return `INSERT INTO ${tableName} ${content};`;
+  getPrimaryKeyColumn(columnInfoEntries) {
+    for (const key in columnInfoEntries) {
+      const columnInfo = columnInfoEntries[key];
+      if (columnInfo.isPrimaryKey)
+        return columnInfo.name;
+    }
   }
   /**
-   * A SQL insert query string. See {@link insert()}.
-   *
-   * @param keys - An array of column names to be used in the query.
-   * @param [valueString] - An optional preformatted value string to be included in the query.
-   * If not provided, the method generates a default placeholder string with "?" for each key.
-   * @return The SQL statement as a string.
+   * 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.
    */
-  insertValues(keys, valueString) {
-    return `(${keys}) ${valueString ?? `VALUES (${keys.map(() => "?").join(",")})`}`;
+  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) => {
+        Logger.log(`Column ${tableName}.${oldColumnName} will be renamed to ${tableName}.${newColumnName}!`);
+        changes.up += this.dialect.renameColumn(tableName, oldColumnName, newColumnName);
+        changes.down += this.dialect.renameColumn(tableName, newColumnName, oldColumnName);
+      });
+    }
+    return changes;
   }
-  /**
-   * Returns a SQL query string to create a migration table.
-   * The table is used to store migration data, specifically the version of the migration.
-   *
-   * @return The SQL query string for creating the migration table.
-   */
-  migrationTableQuery() {
-    return this.createTable(MIGRATION_DATA_TABLE_NAME, [
-      this.columnDefinition("version", this.types.number, false, "0")
-    ]);
+};
+
+// src/lib/tableInfo/decorators/TableClass.ts
+import "polyfill-symbol-metadata";
+function TableClass(tableName, primaryKey) {
+  return (table, context) => {
+    const tableStructure = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(table);
+    tableStructure.primaryKey = primaryKey?.toString();
+    tableStructure.table = tableName;
+    if (tableStructure.foreignKeys) {
+      for (const foreignKey of tableStructure.foreignKeys) {
+        foreignKey.fromTable = tableName;
+        if (foreignKey.toTable == table.name)
+          foreignKey.toTable = tableName;
+      }
+    }
+    const obj = new table();
+    for (const key in obj) {
+      const value = obj[key];
+      const existingEntry = tableStructure.columns[key];
+      const defaultEntry = TableObjHelper.getColumnEntry(key, value);
+      if (!defaultEntry)
+        continue;
+      if (key == primaryKey)
+        defaultEntry.isPrimaryKey = true;
+      tableStructure.columns[key] = {
+        ...defaultEntry,
+        ...existingEntry
+      };
+    }
+    Object.defineProperty(table, "name", { value: tableName, writable: false });
+  };
+}
+
+// src/lib/tableInfo/TableObj.ts
+var TableObj = class _TableObj {
+  IS_TABLE_OBJ = true;
+  tableName;
+  tableStructure = {
+    table: "",
+    primaryKey: void 0,
+    columns: {},
+    foreignKeys: []
+  };
+  constructor(tableName, defaultValues) {
+    const addColumnEntry = (key, value) => {
+      const columnEntry = TableObjHelper.getColumnEntry(key, value);
+      if (!columnEntry) {
+        return;
+      }
+      this.tableStructure.columns[key] = columnEntry;
+      return columnEntry;
+    };
+    this.tableName = tableName;
+    this.tableStructure.table = tableName;
+    for (const key in defaultValues) {
+      const content = defaultValues[key];
+      if (Array.isArray(content)) {
+        const [value, options] = content;
+        const columnEntry = addColumnEntry(key, value);
+        if (columnEntry) {
+          this.applyOptions(columnEntry, options);
+        }
+      } else {
+        addColumnEntry(key, content);
+      }
+    }
   }
-  /**
-   * Fetches the foreign keys for the specified table.
-   * This method is only used if {@link canInspectForeignKeys} is true
-   *
-   * @param tableName - The name of the table for which to retrieve foreign key information.
-   * @return {Promise<ForeignKeyInfo[]>} A promise that resolves to an array of {@link ForeignKeyInfo}.
-   */
-  async getForeignKeys(tableName) {
-    throw new Error("Inspecting foreign keys is not supported!");
+  applyOptions(entry, options) {
+    for (const keyString in options) {
+      const key = keyString;
+      switch (key) {
+        case "primaryKey":
+          if (this.tableStructure.primaryKey) {
+            this.tableStructure.columns[this.tableStructure.primaryKey].isPrimaryKey = false;
+          }
+          this.tableStructure.primaryKey = entry.name;
+          entry.isPrimaryKey = true;
+          break;
+        case "dataType":
+          entry.inputType = options[key];
+          break;
+        case "maxCharacterLength":
+          entry.maxLength = options[key];
+          break;
+        default:
+          throw new Error(`Unsupported option "${key}" for ${this.tableName}.${entry.name}`);
+      }
+    }
   }
   /**
-   * Ensures that the migration table exists in the database.
-   * If the table does not exist, it creates the table using the defined migration table query.
+   * Creates a foreign key relationship between the current table and a target table.
    *
-   * @return A promise that resolves when the migration table is created successfully.
+   * @param fromColumn - The column in the current table that will serve as the foreign key.
+   * @param toTable - The target table object that the foreign key will reference.
+   * @param toColumn - The column in the target table that the foreign key will reference.
+   * @param options - Optional configurations for the foreign key, specifying actions on update or delete.
    */
-  async createMigrationTableIfNeeded() {
-    await this.db.runMultipleWriteStatements(this.migrationTableQuery());
+  foreignKey(fromColumn, toTable, toColumn, options) {
+    this.tableStructure.foreignKeys.push({
+      fromTable: this.tableName,
+      fromColumn: fromColumn.toString(),
+      toTable: toTable.tableName,
+      toColumn: toColumn.toString(),
+      onUpdate: options?.onUpdate,
+      onDelete: options?.onDelete
+    });
+    return this;
   }
   /**
-   * Retrieves the current version from the migration data table.
-   *
-   * @return A promise that resolves to the current version number. Returns 0 if no version is found.
+   * An optional helper function to deal with `TS2589: Type instantiation is excessively deep and possibly infinite. when used as method parameter`
+   * Does nothing in runtime
    */
-  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;
+  sealType() {
+    return this;
   }
-  /**
-   * Updates the migration version in the database. If the version entry does not exist, it inserts a new one;
-   * if it exists, it updates the version to the specified value.
-   *
-   * @param newVersion - The new migration version to set in the database.
-   * @return A promise that resolves when the operation is complete.
-   */
-  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);
+  static create(tableName, columns) {
+    return new _TableObj(tableName, columns);
   }
 };
 
+// src/lib/tableInfo/decorators/DataType.ts
+import "polyfill-symbol-metadata";
+function DataType(type) {
+  return (table, context) => {
+    const entry = getInputColumnInfo(table, context);
+    entry.inputType = type;
+  };
+}
+
+// src/lib/tableInfo/decorators/ForeignKey.ts
+import "polyfill-symbol-metadata";
+function ForeignKey(toTable, toColumn, options) {
+  return (table, context) => {
+    const metadata = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(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: options?.onDelete,
+      onUpdate: options?.onUpdate
+    });
+  };
+}
+
 // src/lib/dialects/SqliteDialect.ts
 var SqliteDialect = class extends DefaultSql {
   types = {
+    text: "TEXT",
     string: "TEXT",
     number: "INTEGER",
     bigint: "INTEGER",
     boolean: "INTEGER",
     date: "INTEGER",
     time: "INTEGER",
-    dateTime: "INTEGER",
-    null: "NULL"
+    dateTime: "INTEGER"
   };
+  canRecreateTable = true;
+  canAlterColumnStructure = false;
   canAlterForeignKeys = false;
   canAlterPrimaryKey = false;
-  canInspectForeignKeys = true;
-  canInspectPrimaryKey = true;
-  changeForeignKeysState(enabled) {
-    return `PRAGMA foreign_keys = ${enabled ? "ON" : "OFF"};`;
+  async runTransactionWithoutForeignKeys(query) {
+    await this.db.runWriteStatement(`PRAGMA foreign_keys = OFF;`);
+    await this.db.runWriteStatement(`PRAGMA defer_foreign_keys = ON;`);
+    await this.db.runTransaction(query);
+    await this.db.runWriteStatement(`PRAGMA foreign_keys = ON;`);
+    await this.db.runWriteStatement(`PRAGMA foreign_key_check;`);
+    await this.db.runWriteStatement(`PRAGMA defer_foreign_keys = OFF;`);
   }
   async getTableNames() {
-    return (await this.db.runGetStatement("SELECT name FROM sqlite_master WHERE type = 'table'")).map((obj) => obj.name);
+    return (await this.db.runReadStatement("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})`);
+    const data = await this.db.runReadStatement(`PRAGMA table_info(${tableName})`);
     const output = {};
     for (const entry of data) {
       output[entry["name"]] = {
         name: entry["name"],
-        type: entry["type"],
-        defaultValue: entry["dflt_value"],
+        sqlType: entry["type"],
+        defaultValue: entry["dflt_value"] ?? this.nullType,
         isPrimaryKey: entry["pk"] == "1"
       };
     }
@@ -1346,7 +1406,7 @@ var SqliteDialect = class extends DefaultSql {
     }
   }
   async getForeignKeys(tableName) {
-    const data = await this.db.runGetStatement(`PRAGMA foreign_key_list(${tableName});`);
+    const data = await this.db.runReadStatement(`PRAGMA foreign_key_list(${tableName});`);
     return data.map((entry) => {
       return {
         fromTable: tableName,
@@ -1358,43 +1418,86 @@ var SqliteDialect = class extends DefaultSql {
       };
     });
   }
+  async setChanges(fromVersion, toVersion, changes) {
+    await this.db.runTransaction(`PRAGMA user_version = ${toVersion};`);
+    await super.setChanges(fromVersion, toVersion, changes);
+  }
   async getVersion() {
-    const output = await this.db.runGetStatement(`PRAGMA user_version;`);
+    const output = await this.db.runReadStatement(`PRAGMA user_version;`);
     return output[0].user_version;
   }
-  async setVersion(newVersion) {
-    await this.db.runMultipleWriteStatements(`PRAGMA user_version = ${newVersion};`);
+  async rollbackHistory(toVersion) {
+    await this.db.runTransaction(`PRAGMA user_version = ${toVersion};`);
+    await super.rollbackHistory(toVersion);
   }
 };
 
 // src/lib/dialects/PostgresDialect.ts
 var PostgresDialect = class extends DefaultSql {
+  canRecreateTable = false;
+  canAlterColumnStructure = true;
   canAlterForeignKeys = true;
   canAlterPrimaryKey = true;
-  canInspectForeignKeys = false;
-  canInspectPrimaryKey = false;
-  changeForeignKeysState(enabled) {
-    return `SET session_replication_role = '${enabled ? "replica" : "origin"}';`;
+  types = {
+    text: "TEXT",
+    string: "VARCHAR",
+    number: "NUMERIC",
+    bigint: "BIGINT",
+    boolean: "BOOLEAN",
+    date: "DATE",
+    time: "TIME",
+    dateTime: "TIMESTAMP"
+  };
+  formatIdentifier(identifier) {
+    return `"${identifier}"`;
+  }
+  alterColumnStructure(tableName, columnName, sqlType, defaultValue) {
+    return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${sqlType}; ALTER TABLE ${tableName} ALTER COLUMN ${columnName} ${defaultValue ? `SET DEFAULT ${defaultValue}` : "DROP DEFAULT"};`;
+  }
+  async runTransactionWithoutForeignKeys(query) {
+    await this.db.runTransaction(`SET session_replication_role = 'replica'; ${query}; SET session_replication_role = 'origin';`);
   }
   addForeignKey(fromTableName, foreignKey) {
-    return `ALTER TABLE ${fromTableName} ADD CONSTRAINT ${fromTableName} ${foreignKey};`;
+    return `ALTER TABLE ${this.formatIdentifier(fromTableName)} ADD CONSTRAINT ${this.formatIdentifier(fromTableName)} ${foreignKey};`;
   }
   removeForeignKey(tableName, foreignKeyName) {
-    return `ALTER TABLE ${tableName} DROP CONSTRAINT ${foreignKeyName};`;
+    return `ALTER TABLE ${this.formatIdentifier(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';");
+    const result = await this.db.runReadStatement("SELECT table_name FROM information_schema.tables WHERE table_schema='public' AND table_type='BASE TABLE';");
+    return result.map((row) => row.table_name);
   }
   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}';`);
+    const data = await this.db.runReadStatement(`SELECT c.column_name as column_name, data_type, column_default, constraint_type FROM information_schema.columns c LEFT JOIN information_schema.key_column_usage cu ON cu.table_name = c.table_name AND cu.column_name = c.column_name LEFT JOIN information_schema.table_constraints tc ON tc.constraint_name = cu.constraint_name WHERE c.table_schema = 'public' AND c.table_name = '${tableName}';`);
     const output = {};
     for (const entry of data) {
-      output[entry["name"]] = {
+      const defaultValue = entry["column_default"]?.match(/^'(.+)'::.+$/);
+      let dataType = entry["data_type"].toUpperCase();
+      switch (dataType) {
+        case "INTEGER":
+          dataType = this.types.number;
+          break;
+        case "CHARACTER VARYING":
+          dataType = this.types.string;
+          break;
+        case "TIMESTAMP WITHOUT TIME ZONE":
+        case "TIMESTAMP WITH TIME ZONE":
+          dataType = this.types.dateTime;
+          break;
+        case "TIME WITHOUT TIME ZONE":
+        case "TIME WITH TIME ZONE":
+          dataType = this.types.time;
+          break;
+        case "DATE WITHOUT TIME ZONE":
+        case "DATE WITH TIME ZONE":
+          dataType = this.types.date;
+          break;
+      }
+      output[entry["column_name"]] = {
         name: entry["column_name"],
-        type: entry["data_type"],
-        maxLength: 0,
-        defaultValue: entry["column_default"],
-        isPrimaryKey: false
+        sqlType: dataType,
+        defaultValue: defaultValue ? `'${defaultValue[1]}'` : entry["column_default"] ?? this.nullType,
+        isPrimaryKey: entry["constraint_type"] == "PRIMARY KEY"
       };
     }
     return output;
@@ -1407,85 +1510,77 @@ var PostgresDialect = class extends DefaultSql {
     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"}"`;
-  }
-  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};`);
+    const data = await this.db.runReadStatement(
+      `SELECT
+				tc.table_name AS child_table,
+				kcu.column_name AS child_column,
+                ccu.table_name AS parent_table,
+				ccu.column_name AS parent_column,
+				rc.update_rule AS update_rule,
+				rc.delete_rule AS delete_rule
+			FROM information_schema.table_constraints AS tc
+				JOIN information_schema.key_column_usage AS kcu
+					ON tc.constraint_name = kcu.constraint_name
+				JOIN information_schema.constraint_column_usage AS ccu
+					ON tc.constraint_name = ccu.constraint_name
+                JOIN information_schema.referential_constraints AS rc
+                     ON tc.constraint_name=rc.constraint_name
+			WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = '${tableName}';`
+    );
     return data.map((entry) => {
       return {
-        fromTable: entry[tableName],
-        fromColumn: entry["FKCOLUMN_NAME"],
-        toTable: entry["PKTABLE_NAME"],
-        toColumn: entry["PKCOLUMN_NAME"]
+        fromTable: tableName,
+        fromColumn: entry["child_column"],
+        toTable: entry["parent_table"],
+        toColumn: entry["parent_column"],
+        onUpdate: entry["update_rule"],
+        onDelete: entry["delete_rule"]
       };
     });
   }
-  async getTableNames() {
-    return (await this.db.runGetStatement("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'")).map((entry) => entry.name);
-  }
-  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};'`);
-    const output = {};
-    for (const entry of data) {
-      output[entry["name"]] = {
-        name: entry["name"],
-        type: entry["DATA_TYPE"],
-        maxLength: 0,
-        defaultValue: entry["COLUMN_DEFAULT"],
-        isPrimaryKey: entry["pk"] == "1"
-      };
-    }
-    return output;
-  }
 };
 
 // src/lib/dialects/MySqlDialect.ts
 var MySqlDialect = class extends DefaultSql {
+  canRecreateTable = true;
+  canAlterColumnStructure = true;
   canAlterForeignKeys = true;
   canAlterPrimaryKey = true;
-  canInspectForeignKeys = true;
-  canInspectPrimaryKey = true;
   types = {
+    text: "TEXT",
     string: "VARCHAR",
     number: "INT",
     bigint: "BIGINT",
-    boolean: "BOOLEAN",
+    boolean: "TINYINT(1)",
     date: "DATE",
     time: "TIME",
-    dateTime: "DATETIME",
-    null: "NULL"
+    dateTime: "DATETIME"
   };
+  formatValueToSql(value, type) {
+    switch (type) {
+      case "boolean":
+        return value ? "1" : "0";
+      default:
+        return super.formatValueToSql(value, type);
+    }
+  }
   getSqlType(dataType, columnInfo) {
     switch (dataType) {
       case "string":
-        return this.types[dataType] + `(${columnInfo?.maxLength})`;
+        return this.types[dataType] + `(${columnInfo?.maxLength ?? 100})`;
       default:
         return super.getSqlType(dataType, columnInfo);
     }
   }
-  changeForeignKeysState(enabled) {
-    return `SET FOREIGN_KEY_CHECKS ${enabled ? "1" : "0"};`;
+  alterColumnStructure(tableName, columnName, sqlType, defaultValue) {
+    const typeQuery = `ALTER TABLE ${tableName} MODIFY COLUMN ${columnName} ${sqlType}`;
+    return defaultValue ? `${typeQuery} DEFAULT ${defaultValue}` : `${typeQuery}; ALTER TABLE ${tableName} ALTER ${columnName} DROP DEFAULT;`;
+  }
+  async runTransactionWithoutForeignKeys(query) {
+    await this.db.runWriteStatement("SET FOREIGN_KEY_CHECKS = 0;");
+    await this.db.runTransaction(query);
+    await this.db.runWriteStatement("SET FOREIGN_KEY_CHECKS = 1;");
   }
   addForeignKey(fromTableName, foreignKey) {
     return `ALTER TABLE ${fromTableName} ADD ${foreignKey};`;
@@ -1500,80 +1595,102 @@ var MySqlDialect = class extends DefaultSql {
     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}';`);
+    const data = await this.db.runReadStatement(
+      `SELECT
+				info.TABLE_NAME, info.COLUMN_NAME, info.REFERENCED_TABLE_NAME, info.REFERENCED_COLUMN_NAME, constr.UPDATE_RULE, constr.DELETE_RULE
+			FROM information_schema.KEY_COLUMN_USAGE AS info INNER JOIN information_schema.REFERENTIAL_CONSTRAINTS AS constr ON info.CONSTRAINT_NAME = constr.CONSTRAINT_NAME
+			WHERE info.REFERENCED_TABLE_SCHEMA = (SELECT DATABASE()) AND info.TABLE_NAME = '${tableName}';`
+    );
     return data.map((entry) => {
       return {
         fromTable: tableName,
         fromColumn: entry["COLUMN_NAME"],
         toTable: entry["REFERENCED_TABLE_NAME"],
-        toColumn: entry["REFERENCED_COLUMN_NAME"]
+        toColumn: entry["REFERENCED_COLUMN_NAME"],
+        onUpdate: entry["UPDATE_RULE"],
+        onDelete: entry["DELETE_RULE"]
       };
     });
   }
   async getTableNames() {
-    const entries = await this.db.runGetStatement("SHOW TABLES");
+    const entries = await this.db.runReadStatement("SHOW TABLES");
     return entries.map((entry) => Object.values(entry)[0]);
   }
   async getColumnInformation(tableName) {
-    const data = await this.db.runGetStatement(`SHOW COLUMNS FROM ${tableName};`);
+    const data = await this.db.runReadStatement(`SHOW COLUMNS FROM ${tableName};`);
     const output = {};
     for (const entry of data) {
-      const lengthMatch = entry["Type"].match(/^\w+\((\d+)\)/);
-      output[entry["Field"]] = {
+      const sqlType = entry["Type"].toUpperCase();
+      const info = {
         name: entry["Field"],
-        type: entry["Type"],
-        maxLength: lengthMatch ? parseInt(lengthMatch[1]) ?? 0 : 0,
-        defaultValue: entry["Default"],
+        sqlType,
         isPrimaryKey: entry["Key"] == "PRI"
       };
+      switch (sqlType.substring(0, 4)) {
+        case "TEXT":
+        case "VARC":
+        case "DATE":
+        case "TIME":
+          info.defaultValue = entry["Default"] ? `'${entry["Default"]}'` : this.nullType;
+          break;
+        default:
+          info.defaultValue = entry["Default"] ?? this.nullType;
+      }
+      output[entry["Field"]] = info;
     }
     return output;
   }
 };
 
 // src/lib/getDialect.ts
-function getDialect(db, dbInstructions) {
-  switch (dbInstructions.dialect) {
+function getDialect(db, dialect) {
+  switch (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}`);
+      throw new Error(`Unknown dialect ${dialect}`);
   }
 }
 
 // src/index.ts
 async function runMigration(db, dbInstructions) {
   Logger.setMode(dbInstructions.loggerMode);
-  const dialect = getDialect(db, dbInstructions);
+  const dialect = getDialect(db, dbInstructions.dialect);
   const mm = new MigrationManager(dialect);
   const migration = await mm.generateSqlChanges(dbInstructions);
   if (migration) {
-    const migrationHistoryManager = new MigrationHistoryManager(dbInstructions.configPath);
-    migrationHistoryManager.createMigrationHistory(migration.fromVersion, dbInstructions.version, migration.changes);
+    await dialect.setChanges(migration.fromVersion, dbInstructions.version, migration.changes);
     await db.createBackup?.(`from_${migration.fromVersion}_to_${dbInstructions.version}`);
-    await db.runMultipleWriteStatements(migration.changes.up);
+    await dialect.runTransactionWithoutForeignKeys(migration.changes.up);
   }
 }
-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}`);
+async function rollback(dbAccess, toVersion, dialect, loggerMode) {
+  Logger.setMode(loggerMode);
+  const sql = getDialect(dbAccess, dialect);
+  const fromVersion = await sql.getVersion();
+  await dbAccess.createBackup?.(`from_${fromVersion}_to_${toVersion}`);
   Logger.log(`Rolling back from ${fromVersion} to ${toVersion}`);
-  for (let i = fromVersion - 1; i >= toVersion; --i) {
-    const upChanges = historyManager.getDownMigration(i);
-    Logger.debug(upChanges);
-    await db.runMultipleWriteStatements(upChanges);
-    dbInstructions.version = i;
+  let version = fromVersion;
+  while (version > toVersion) {
+    const changes = await sql.getChanges(version);
+    if (!changes) {
+      throw new Error(`No changes found for version ${version}`);
+    } else if (changes.fromVersion == version) {
+      throw new Error(`Saved changes do not change the database version (${version})`);
+    }
+    Logger.debug(changes.down);
+    await sql.runTransactionWithoutForeignKeys(changes.down);
+    version = changes.fromVersion;
+  }
+  if (version < toVersion) {
+    Logger.warn(`There was no entry for version ${toVersion}. Rolled back to version ${version}`);
   }
-  await dialect.setVersion(toVersion);
+  await sql.rollbackHistory(version);
+  return version;
 }
 export {
   DataType,