npm - sqlmorpheus - Versions diffs - 0.2.7 → 1.0.1 - Mend

sqlmorpheus 0.2.7 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/index.mjs CHANGED Viewed

@@ -1,788 +1,768 @@
-// src/lib/Logger.ts
+import escapeString from "escape-sql-string";
+import "polyfill-symbol-metadata";
+//#region src/lib/Logger.ts
+/**
+* A simple LoggerClass which provides functionality for logging messages
+* in different modes such as normal, debug, silent, and noLog.
+* It allows controlling the verbosity of logs based on the mode.
+*/
 var LoggerClass = class {
-  mode = "log";
-  setMode(mode) {
-    this.mode = mode ?? "log";
-  }
-  debug(text) {
-    if (this.mode == "debug") {
-      console.debug(`\x1B[90m${(/* @__PURE__ */ new Date()).toLocaleTimeString()}\x1B[0m ${text}`);
-    }
-  }
-  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 == "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}`);
-    }
-  }
+	mode = "log";
+	setMode(mode) {
+		this.mode = mode ?? "log";
+	}
+	debug(text) {
+		if (this.mode == "debug") console.debug(`\x1b[90m${(/* @__PURE__ */ new Date()).toLocaleTimeString()}\x1b[0m ${text}`);
+	}
+	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 == "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/TableObjHelper.ts
-var TableObjHelper = class _TableObjHelper {
-  static isTableObj(obj) {
-    return !!obj?.IS_TABLE_OBJ;
-  }
-  static getEmptyColumnEntry(key) {
-    return {
-      name: key,
-      sqlType: "",
-      defaultValue: "",
-      isPrimaryKey: false
-    };
-  }
-  static getColumnEntry(key, value) {
-    let dataType = typeof value;
-    switch (typeof value) {
-      case "function":
-        return null;
-      case "object":
-        if (value instanceof Date) {
-          dataType = "date";
-          break;
-        } else if (value !== null) {
-          Logger.warn(`${key} was skipped because its type (${typeof value}) is not supported`);
-          return null;
-        }
-        dataType = "string";
-        break;
-      case "undefined":
-      case "symbol":
-        Logger.warn(`${key} was skipped because its type (${typeof value}) is not supported`);
-        return null;
-    }
-    return {
-      ..._TableObjHelper.getEmptyColumnEntry(key),
-      inputType: dataType,
-      inputDefaultValue: value
-    };
-  }
+const Logger = new LoggerClass();
+//#endregion
+//#region src/lib/tableInfo/TableObjHelper.ts
+var TableObjHelper = class TableObjHelper {
+	static isTableObj(obj) {
+		return !!obj?.IS_TABLE_OBJ;
+	}
+	static getEmptyColumnEntry(key) {
+		return {
+			name: key,
+			sqlType: "",
+			defaultValue: "",
+			isPrimaryKey: false
+		};
+	}
+	static getColumnEntry(key, value) {
+		let dataType = typeof value;
+		switch (typeof value) {
+			case "function": return null;
+			case "object":
+				if (value instanceof Date) {
+					dataType = "date";
+					break;
+				} else if (value !== null) {
+					Logger.warn(`${key} was skipped because its type (${typeof value}) is not supported`);
+					return null;
+				}
+				dataType = "string";
+				break;
+			case "undefined":
+			case "symbol":
+				Logger.warn(`${key} was skipped because its type (${typeof value}) is not supported`);
+				return null;
+		}
+		return {
+			...TableObjHelper.getEmptyColumnEntry(key),
+			inputType: dataType,
+			inputDefaultValue: value
+		};
+	}
 };
-// src/lib/tableInfo/getTableStructure.ts
-var TABLE_INFO_PROPERTY_NAME = Symbol("tableInfo");
+//#endregion
+//#region src/lib/tableInfo/getTableStructure.ts
+const TABLE_INFO_PROPERTY_NAME = Symbol("tableInfo");
 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] = TableObjHelper.getEmptyColumnEntry(key);
-  return metadata.columns[key];
+	const metadata = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(table);
+	const key = context.name ?? context;
+	if (!metadata.columns.hasOwnProperty(key)) metadata.columns[key] = TableObjHelper.getEmptyColumnEntry(key);
+	return metadata.columns[key];
 }
+/**
+* Retrieves table information based on the provided class and their decorators.
+* If the table metadata property does not exist in the metadata,
+* it initializes a default structure.
+*
+* @param table - The class representing the table.
+* @return The table information as a `TableInfo` object.
+*/
 function getTableStructure(table) {
-  let metadata = table[Symbol.metadata] ?? table.prototype?.[Symbol.metadata];
-  if (!metadata) {
-    metadata = {};
-    table[Symbol.metadata] = metadata;
-  }
-  return getTableStructureFromMetadata(metadata);
+	let metadata = table[Symbol.metadata] ?? table.prototype?.[Symbol.metadata];
+	if (!metadata) {
+		metadata = {};
+		table[Symbol.metadata] = metadata;
+	}
+	return getTableStructureFromMetadata(metadata);
 }
+/**
+* Extracts and returns table information from the provided metadata object.
+* If the specified table information property does not exist in the metadata,
+* it initializes a default structure.
+*
+* @param metadata - The metadata object which potentially contains table information.
+* @return {InputTableStructure} The table information retrieved or initialized from the metadata.
+*/
 function getTableStructureFromMetadata(metadata) {
-  if (!metadata[TABLE_INFO_PROPERTY_NAME])
-    metadata[TABLE_INFO_PROPERTY_NAME] = { table: "", primaryKey: "", foreignKeys: [], columns: {} };
-  return metadata[TABLE_INFO_PROPERTY_NAME];
+	if (!metadata[TABLE_INFO_PROPERTY_NAME]) metadata[TABLE_INFO_PROPERTY_NAME] = {
+		table: "",
+		primaryKey: "",
+		foreignKeys: [],
+		columns: {}
+	};
+	return metadata[TABLE_INFO_PROPERTY_NAME];
 }
-// src/lib/TableStructureGenerator.ts
+//#endregion
+//#region src/lib/TableStructureGenerator.ts
+/**
+* Represents a generator for creating table structures based on specified database instructions
+*/
 var TableStructureGenerator = class {
-  dialect;
-  dbInstructions;
-  constructor(dbInstructions, dialect) {
-    this.dialect = dialect;
-    this.dbInstructions = dbInstructions;
-  }
-  /**
-   * Generates the structure of tables based on database instructions.
-   *
-   * @return An object where keys are table names, and values are their corresponding table structures.
-   */
-  generateTableStructure() {
-    const tables = {};
-    for (const table of this.dbInstructions.tables) {
-      let structure;
-      if (TableObjHelper.isTableObj(table)) {
-        structure = table.tableStructure;
-        tables[table.tableName] = table.tableStructure;
-      } else {
-        const classTable = table;
-        structure = getTableStructure(classTable);
-        tables[classTable.name] = structure;
-      }
-      for (const key in structure.columns) {
-        const entry = structure.columns[key];
-        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;
-  }
+	dialect;
+	dbInstructions;
+	constructor(dbInstructions, dialect) {
+		this.dialect = dialect;
+		this.dbInstructions = dbInstructions;
+	}
+	/**
+	* Generates the structure of tables based on database instructions.
+	*
+	* @return An object where keys are table names, and values are their corresponding table structures.
+	*/
+	generateTableStructure() {
+		const tables = {};
+		for (const table of this.dbInstructions.tables) {
+			let structure;
+			if (TableObjHelper.isTableObj(table)) {
+				structure = table.tableStructure;
+				tables[table.tableName] = table.tableStructure;
+			} else {
+				const classTable = table;
+				structure = getTableStructure(classTable);
+				tables[classTable.name] = structure;
+			}
+			for (const key in structure.columns) {
+				const entry = structure.columns[key];
+				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
+//#endregion
+//#region src/lib/typings/AllowedMigrations.ts
+const ALLOWED = "allowed";
+const USED = "allowedAndUsed";
+const NO_COLUMN = "noColumn";
+//#endregion
+//#region 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}"${entry.column != NO_COLUMN ? `, "${entry.column}"` : ""});
-`;
-    }
-    super(message);
-  }
+	constructor(entries) {
+		let message = "Some destructive changes need to be confirmed. To confirm, add to preMigration():\n";
+		for (const entry of entries) message += `\t\tmigrations.allowMigration(${entry.version}, "${entry.tableName}", "${entry.type.toString()}"${entry.column != "noColumn" ? `, "${entry.column}"` : ""});\n`;
+		super(message);
+	}
 };
-// src/lib/Migrations.ts
+//#endregion
+//#region src/lib/Migrations.ts
+/**
+* The Migrations class is responsible for managing manual database schema migrations.
+*/
 var Migrations = class {
-  fromVersion = 0;
-  toVersion = 0;
-  lastUsedVersion = 0;
-  migrationData = {};
-  migrationDataForOldTableNames = {};
-  alwaysAllowed = [];
-  notAllowedChanges = [];
-  /**
-   * Resets the migration state to its initial values.
-   * Only used internally.
-   *
-   * @param dbInstructions - The instructions containing database metadata and migration details.
-   * @param fromVersion - The version of the actual database.
-   */
-  reset(dbInstructions, fromVersion) {
-    this.fromVersion = fromVersion;
-    this.toVersion = dbInstructions.version;
-    this.migrationData = {};
-    this.migrationDataForOldTableNames = {};
-    this.alwaysAllowed = dbInstructions.alwaysAllowedMigrations ?? [];
-    this.notAllowedChanges = [];
-  }
-  /**
-   * Retrieves the migration instructions for the specified table.
-   *
-   * @param tableName - The name of the table for which the entry is to be retrieved or created.
-   * @return The migration instructions corresponding to the given table input.
-   */
-  getEntryFromTableName(tableName) {
-    if (!this.migrationData.hasOwnProperty(tableName)) {
-      this.migrationData[tableName] = {
-        recreate: false,
-        renamedColumns: [],
-        allowedMigrations: {}
-      };
-    }
-    return this.migrationData[tableName];
-  }
-  /**
-   * 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.
-   *
-   * @param version - The version to check for relevance.
-   * @return Returns true if the version is relevant, otherwise false.
-   * @throws Error if versions are not properly ordered
-   */
-  versionIsRelevant(version) {
-    if (version <= this.fromVersion || version > this.toVersion) {
-      return false;
-    }
-    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;
-  }
-  /**
-   * Verifies the renaming tasks specified in {@link DatabaseInstructions.preMigration} that were considered are valid.
-   * Called after all SQL queries have been generated.
-   * Only used internally.
-   *
-   * @param newTables - The table structures extracted from {@link DatabaseInstructions.tables}.
-   * @throws Error if a renaming task is invalid.
-   */
-  verifyRenamingTasks(newTables) {
-    for (const tableName in this.migrationData) {
-      const migrationEntry = this.migrationData[tableName];
-      if (migrationEntry.tableRenaming) {
-        if (migrationEntry.tableRenaming.oldName == tableName) {
-          return new Error(`You set table "${tableName}" to be renamed to itself!`);
-        }
-        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 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) {
-          return new Error(`You set column ${tableName}.${oldColumnName} to be renamed to itself!`);
-        } 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.`);
-        }
-      }
-    }
-  }
-  /**
-   * Making sure all considered calls to {@link allowMigration()} where necessary to prevent input mistakes.
-   * Called after all SQL queries have been generated.
-   * Only used internally.
-   *
-   * @throws Error if unnecessary calls were discovered. All discovered calls are collected and thrown as one Error.
-   */
-  verifyAllowedMigrations() {
-    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) {
-        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) {
-      return new Error(errorMsg);
-    }
-  }
-  /**
-   * Called by {@link MigrationManager} to check if a specific destructive query is allowed.
-   * Only used internally.
-   *
-   * @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, column = NO_COLUMN) {
-    const migrationEntry = this.migrationData[tableName];
-    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.
-   * Only used internally.
-   *
-   * @return An object where each key corresponds to the table name,
-   * and the value is the associated migration instructions.
-   */
-  getMigrationData() {
-    return this.migrationData;
-  }
-  /**
-   * Iterates over renamed columns for the specified table and executes a callback for each pair of old and new column names.
-   * Only used internally.
-   *
-   * @param tableName - Name of the table whose renamed columns should be processed.
-   * @param callback - A function to execute for each renamed column, receiving the old and new column names as arguments.
-   */
-  loopRenamedColumns(tableName, callback) {
-    const migrationEntry = this.migrationData[tableName];
-    for (const renamingData of migrationEntry.renamedColumns) {
-      callback(renamingData.oldName, renamingData.newName);
-    }
-  }
-  /**
-   * Considers the renaming of a table and returns its (newest) name after the migration or
-   * the original name if no renaming is queued.
-   * Only used internally.
-   *
-   * @see getOldTableName()
-   * @param tableName - The current table name in the database.
-   * @return The newest table name if available, otherwise the current table name.
-   */
-  getNewestTableName(tableName) {
-    return this.migrationDataForOldTableNames[tableName]?.tableRenaming?.newName ?? tableName;
-  }
-  /**
-   * Retrieves the current table name in the database.
-   * Only used internally.
-   *
-   * @see getNewestTableName()
-   * @param tableName - The name of the newest table name.
-   * @return The current table name in the database.
-   */
-  getOldTableName(tableName) {
-    return this.migrationData[tableName]?.tableRenaming?.oldName ?? tableName;
-  }
-  /**
-   * Considers the renaming of a column in a table and returns its (newest) name after the migration or
-   * the original name if no renaming is queued.
-   * Only used internally.
-   *
-   * @param tableName - The name of the table containing the column.
-   * @param oldColumnName - The current name of the column in the database.
-   * @return The newest column name if available, otherwise the original column name.
-   */
-  getNewestColumnName(tableName, oldColumnName) {
-    const columnNames = this.migrationData[tableName]?.renamedColumns.find((columns) => columns.oldName == oldColumnName);
-    return columnNames ? columnNames.newName : oldColumnName;
-  }
-  /**
-   * Determines if the specified table is marked to be recreated.
-   * Only used internally.
-   *
-   * @param tableName The name of the table to check.
-   * @return Returns true if the table will be recreated, false otherwise.
-   */
-  willBeRecreated(tableName) {
-    return this.migrationData[tableName]?.recreate;
-  }
-  /**
-   * Marks a table to be recreated and logs the recreation reason for the user.
-   * Only used internally.
-   *
-   * @param tableName - The name of the table to be marked for recreation.
-   * @param reason - The reason why the table is being marked for recreation.
-   */
-  internalRecreate(tableName, reason) {
-    const entry = this.getEntryFromTableName(tableName);
-    entry.recreate = true;
-    Logger.log(`Table ${tableName} will be recreated (${reason})!`);
-  }
-  /**
-   * SqlMorpheus only allows destructive statements if it was specifically allowed in {@link DatabaseInstructions.preMigration()}.
-   * Use this method to allow a destructive statement for a specific version.
-   * 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 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, tableName, allowedMigration, column) {
-    if (!this.versionIsRelevant(version)) {
-      return;
-    }
-    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.`);
-      }
-    }
-  }
-  /**
-   * When you change the name of a table, SqlMorpheus will assume the original table was meant to be dropped
-   * and the new table was meant to be added, which would lead to data loss.
-   * Use this method to mark a table to be renamed instead.
-   * 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 version.
-   * @param newTableName - The new table name at the time of the migration version.
-   */
-  renameTable(version, oldTableName, newTableName) {
-    if (!this.versionIsRelevant(version)) {
-      return;
-    }
-    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: 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
-   * and the new column was meant to be added, which would lead to data loss.
-   * Use this method to mark a column to be renamed instead.
-   * 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 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, tableName, oldColumn, newColumn) {
-    if (!this.versionIsRelevant(version)) {
-      return;
-    }
-    const entry = this.getEntryFromTableName(tableName);
-    const existingColumnEntry = entry.renamedColumns.find((entry2) => entry2.newName == oldColumn);
-    if (existingColumnEntry) {
-      existingColumnEntry.newName = newColumn;
-    } else {
-      entry.renamedColumns.push({ oldName: oldColumn, newName: newColumn });
-    }
-  }
-  /**
-   * Should not be needed most of the time.
-   * Marks a table to be recreated
-   * (a copy of the table will be created, all data will be moved over, the original table will be dropped and the new table will be renamed to the original name).
-   * 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 tableName - The current table name in the database at the time of the migration version.
-   */
-  recreateTable(version, tableName) {
-    if (!this.versionIsRelevant(version)) {
-      return;
-    }
-    const entry = this.getEntryFromTableName(tableName);
-    entry.recreate = true;
-    Logger.log(`Table ${tableName} will be recreated!`);
-    this.allowMigration(version, tableName, "recreateTable");
-  }
+	fromVersion = 0;
+	toVersion = 0;
+	lastUsedVersion = 0;
+	migrationData = {};
+	migrationDataForOldTableNames = {};
+	alwaysAllowed = [];
+	notAllowedChanges = [];
+	/**
+	* Resets the migration state to its initial values.
+	* Only used internally.
+	*
+	* @param dbInstructions - The instructions containing database metadata and migration details.
+	* @param fromVersion - The version of the actual database.
+	*/
+	reset(dbInstructions, fromVersion) {
+		this.fromVersion = fromVersion;
+		this.toVersion = dbInstructions.version;
+		this.migrationData = {};
+		this.migrationDataForOldTableNames = {};
+		this.alwaysAllowed = dbInstructions.alwaysAllowedMigrations ?? [];
+		this.notAllowedChanges = [];
+	}
+	/**
+	* Retrieves the migration instructions for the specified table.
+	*
+	* @param tableName - The name of the table for which the entry is to be retrieved or created.
+	* @return The migration instructions corresponding to the given table input.
+	*/
+	getEntryFromTableName(tableName) {
+		if (!this.migrationData.hasOwnProperty(tableName)) this.migrationData[tableName] = {
+			recreate: false,
+			renamedColumns: [],
+			allowedMigrations: {}
+		};
+		return this.migrationData[tableName];
+	}
+	/**
+	* 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.
+	*
+	* @param version - The version to check for relevance.
+	* @return Returns true if the version is relevant, otherwise false.
+	* @throws Error if versions are not properly ordered
+	*/
+	versionIsRelevant(version) {
+		if (version <= this.fromVersion || version > this.toVersion) return false;
+		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;
+	}
+	/**
+	* Verifies the renaming tasks specified in {@link DatabaseInstructions.preMigration} that were considered are valid.
+	* Called after all SQL queries have been generated.
+	* Only used internally.
+	*
+	* @param newTables - The table structures extracted from {@link DatabaseInstructions.tables}.
+	* @throws Error if a renaming task is invalid.
+	*/
+	verifyRenamingTasks(newTables) {
+		for (const tableName in this.migrationData) {
+			const migrationEntry = this.migrationData[tableName];
+			if (migrationEntry.tableRenaming) {
+				if (migrationEntry.tableRenaming.oldName == tableName) return /* @__PURE__ */ new Error(`You set table "${tableName}" to be renamed to itself!`);
+				if (migrationEntry.tableRenaming.newName != tableName) return /* @__PURE__ */ 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 /* @__PURE__ */ 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) return /* @__PURE__ */ new Error(`You set column ${tableName}.${oldColumnName} to be renamed to itself!`);
+				else if (!newTables[tableName]?.columns[newColumnName]) return /* @__PURE__ */ new Error(`You set column ${tableName}.${oldColumnName} to be renamed to ${tableName}.${newColumnName}. But ${tableName}.${newColumnName} does not exist in your structure.`);
+			}
+		}
+	}
+	/**
+	* Making sure all considered calls to {@link allowMigration()} where necessary to prevent input mistakes.
+	* Called after all SQL queries have been generated.
+	* Only used internally.
+	*
+	* @throws Error if unnecessary calls were discovered. All discovered calls are collected and thrown as one Error.
+	*/
+	verifyAllowedMigrations() {
+		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) {
+				const migrationType = migration.allowedMigrations[type];
+				for (const column in migrationType) if (migrationType[column] != "allowedAndUsed") errorMsg += `Migration \"${type}\" for ${tableName}${column != "noColumn" ? `.${column}` : ""} was allowed but not needed.\n`;
+			}
+		}
+		if (errorMsg) return new Error(errorMsg);
+	}
+	/**
+	* Called by {@link MigrationManager} to check if a specific destructive query is allowed.
+	* Only used internally.
+	*
+	* @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, column = NO_COLUMN) {
+		const migrationEntry = this.migrationData[tableName];
+		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.
+	* Only used internally.
+	*
+	* @return An object where each key corresponds to the table name,
+	* and the value is the associated migration instructions.
+	*/
+	getMigrationData() {
+		return this.migrationData;
+	}
+	/**
+	* Iterates over renamed columns for the specified table and executes a callback for each pair of old and new column names.
+	* Only used internally.
+	*
+	* @param tableName - Name of the table whose renamed columns should be processed.
+	* @param callback - A function to execute for each renamed column, receiving the old and new column names as arguments.
+	*/
+	loopRenamedColumns(tableName, callback) {
+		const migrationEntry = this.migrationData[tableName];
+		for (const renamingData of migrationEntry.renamedColumns) callback(renamingData.oldName, renamingData.newName);
+	}
+	/**
+	* Considers the renaming of a table and returns its (newest) name after the migration or
+	* the original name if no renaming is queued.
+	* Only used internally.
+	*
+	* @see getOldTableName()
+	* @param tableName - The current table name in the database.
+	* @return The newest table name if available, otherwise the current table name.
+	*/
+	getNewestTableName(tableName) {
+		return this.migrationDataForOldTableNames[tableName]?.tableRenaming?.newName ?? tableName;
+	}
+	/**
+	* Retrieves the current table name in the database.
+	* Only used internally.
+	*
+	* @see getNewestTableName()
+	* @param tableName - The name of the newest table name.
+	* @return The current table name in the database.
+	*/
+	getOldTableName(tableName) {
+		return this.migrationData[tableName]?.tableRenaming?.oldName ?? tableName;
+	}
+	/**
+	* Considers the renaming of a column in a table and returns its (newest) name after the migration or
+	* the original name if no renaming is queued.
+	* Only used internally.
+	*
+	* @param tableName - The name of the table containing the column.
+	* @param oldColumnName - The current name of the column in the database.
+	* @return The newest column name if available, otherwise the original column name.
+	*/
+	getNewestColumnName(tableName, oldColumnName) {
+		const columnNames = this.migrationData[tableName]?.renamedColumns.find((columns) => columns.oldName == oldColumnName);
+		return columnNames ? columnNames.newName : oldColumnName;
+	}
+	/**
+	* Determines if the specified table is marked to be recreated.
+	* Only used internally.
+	*
+	* @param tableName The name of the table to check.
+	* @return Returns true if the table will be recreated, false otherwise.
+	*/
+	willBeRecreated(tableName) {
+		return this.migrationData[tableName]?.recreate;
+	}
+	/**
+	* Marks a table to be recreated and logs the recreation reason for the user.
+	* Only used internally.
+	*
+	* @param tableName - The name of the table to be marked for recreation.
+	* @param reason - The reason why the table is being marked for recreation.
+	*/
+	internalRecreate(tableName, reason) {
+		const entry = this.getEntryFromTableName(tableName);
+		entry.recreate = true;
+		Logger.log(`Table ${tableName} will be recreated (${reason})!`);
+	}
+	/**
+	* SqlMorpheus only allows destructive statements if it was specifically allowed in {@link DatabaseInstructions.preMigration()}.
+	* Use this method to allow a destructive statement for a specific version.
+	* 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 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, tableName, allowedMigration, column) {
+		if (!this.versionIsRelevant(version)) return;
+		const entry = this.getEntryFromTableName(tableName);
+		if (!entry.allowedMigrations[allowedMigration]) entry.allowedMigrations[allowedMigration] = {};
+		entry.allowedMigrations[allowedMigration][column ?? "noColumn"] = 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.`);
+		}
+	}
+	/**
+	* When you change the name of a table, SqlMorpheus will assume the original table was meant to be dropped
+	* and the new table was meant to be added, which would lead to data loss.
+	* Use this method to mark a table to be renamed instead.
+	* 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 version.
+	* @param newTableName - The new table name at the time of the migration version.
+	*/
+	renameTable(version, oldTableName, newTableName) {
+		if (!this.versionIsRelevant(version)) return;
+		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: 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
+	* and the new column was meant to be added, which would lead to data loss.
+	* Use this method to mark a column to be renamed instead.
+	* 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 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, tableName, oldColumn, newColumn) {
+		if (!this.versionIsRelevant(version)) return;
+		const entry = this.getEntryFromTableName(tableName);
+		const existingColumnEntry = entry.renamedColumns.find((entry) => entry.newName == oldColumn);
+		if (existingColumnEntry) existingColumnEntry.newName = newColumn;
+		else entry.renamedColumns.push({
+			oldName: oldColumn,
+			newName: newColumn
+		});
+	}
+	/**
+	* Should not be needed most of the time.
+	* Marks a table to be recreated
+	* (a copy of the table will be created, all data will be moved over, the original table will be dropped and the new table will be renamed to the original name).
+	* 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 tableName - The current table name in the database at the time of the migration version.
+	*/
+	recreateTable(version, tableName) {
+		if (!this.versionIsRelevant(version)) return;
+		const entry = this.getEntryFromTableName(tableName);
+		entry.recreate = true;
+		Logger.log(`Table ${tableName} will be recreated!`);
+		this.allowMigration(version, tableName, "recreateTable");
+	}
 };
-// src/lib/dialects/DefaultSql.ts
-import escapeString from "escape-sql-string";
-var MIGRATION_DATA_TABLE_NAME = "__sqlmorpheus_migrations";
+//#endregion
+//#region src/lib/dialects/DefaultSql.ts
+const MIGRATION_DATA_TABLE_NAME = "__sqlmorpheus_migrations";
+/**
+* Provides syntax for SQL queries. Specified dialects extend from this class.
+* Needs a {@link DatabaseAccess} object for database operations
+*/
 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;
-  }
-  /**
-   * 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 "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();
-    }
-  }
-  formatIdentifier(identifier) {
-    return identifier;
-  }
-  getSqlType(dataType, _) {
-    return this.types[dataType];
-  }
-  /**
-   * Changes the column type and the default value of a column in a specified table.
-   * Is only used if {@link canAlterColumnStructure} is true.
-   *
-   * @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.
-   */
-  alterColumnStructure(tableName, columnName, sqlType, defaultValue) {
-    throw new Error("Altering column structure is not supported. Recreate the table instead!");
-  }
-  /**
-   * 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 (${this.formatIdentifier(column)}) REFERENCES ${this.formatIdentifier(foreignTable)} (${this.formatIdentifier(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 ${this.formatIdentifier(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.
-   */
-  renameTable(tableName, newTableName) {
-    return `ALTER TABLE ${this.formatIdentifier(tableName)} RENAME TO ${this.formatIdentifier(newTableName)};`;
-  }
-  /**
-   * Statement to drop a table if it exists.
-   *
-   * @param tableName - The name of the table to be dropped.
-   * @return The SQL statement as a string.
-   */
-  dropTable(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.
-   *
-   * @param columnName - The name of the column.
-   * @param type - The data type of the column.
-   * @param defaultValue - The default value for the column.
-   * @param isPrimaryKey - Indicates whether the column is a primary key.
-   * @return The constructed SQL column definition string.
-   */
-  columnDefinition(columnName, type, isPrimaryKey, defaultValue) {
-    const query = `${this.formatIdentifier(columnName)} ${type}${defaultValue ? ` DEFAULT ${defaultValue}` : ""}`;
-    return isPrimaryKey ? `${query} PRIMARY KEY` : query;
-  }
-  /**
-   * Statement to add a new column to a specified table.
-   *
-   * @param columnTable - The name of the table to which the column will be added.
-   * @param entry - The column definition including the column name and its data type. See {@link columnDefinition()}
-   * @return The SQL statement as a string.
-   */
-  createColumn(columnTable, entry) {
-    return `ALTER TABLE ${this.formatIdentifier(columnTable)} ADD ${entry};`;
-  }
-  /**
-   * Statement to rename a column in an existing table.
-   *
-   * @param tableName - The name of the table containing the column to rename.
-   * @param oldColumnName - The current name of the column to be renamed.
-   * @param newColumnName - The new name for the column.
-   * @return The SQL statement as a string.
-   */
-  renameColumn(tableName, oldColumnName, 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.
-   *
-   * @param tableName - The name of the table from which the column will be dropped.
-   * @param columnName - The name of the column to be dropped.
-   * @return The SQL statement as a string.
-   */
-  dropColumn(tableName, columnName) {
-    return `ALTER TABLE ${this.formatIdentifier(tableName)} DROP COLUMN ${this.formatIdentifier(columnName)};`;
-  }
-  /**
-   * Statement to return data from a table.
-   *
-   * @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, 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.
-   *
-   * @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}
+	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;
+	}
+	/**
+	* 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(value) {
+			return value instanceof Date ? value : new Date(value);
+		}
+		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();
+		}
+	}
+	formatIdentifier(identifier) {
+		return identifier;
+	}
+	getSqlType(dataType, _) {
+		return this.types[dataType];
+	}
+	/**
+	* Changes the column type and the default value of a column in a specified table.
+	* Is only used if {@link canAlterColumnStructure} is true.
+	*
+	* @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.
+	*/
+	alterColumnStructure(tableName, columnName, sqlType, defaultValue) {
+		throw new Error("Altering column structure is not supported. Recreate the table instead!");
+	}
+	/**
+	* 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 (${this.formatIdentifier(column)}) REFERENCES ${this.formatIdentifier(foreignTable)} (${this.formatIdentifier(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 ${this.formatIdentifier(tableName)} (\n\t${entries.join(",\n	")}\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.
+	*/
+	renameTable(tableName, newTableName) {
+		return `ALTER TABLE ${this.formatIdentifier(tableName)} RENAME TO ${this.formatIdentifier(newTableName)};`;
+	}
+	/**
+	* Statement to drop a table if it exists.
+	*
+	* @param tableName - The name of the table to be dropped.
+	* @return The SQL statement as a string.
+	*/
+	dropTable(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.
+	*
+	* @param columnName - The name of the column.
+	* @param type - The data type of the column.
+	* @param defaultValue - The default value for the column.
+	* @param isPrimaryKey - Indicates whether the column is a primary key.
+	* @return The constructed SQL column definition string.
+	*/
+	columnDefinition(columnName, type, isPrimaryKey, defaultValue) {
+		const query = `${this.formatIdentifier(columnName)} ${type}${defaultValue ? ` DEFAULT ${defaultValue}` : ""}`;
+		return isPrimaryKey ? `${query} PRIMARY KEY` : query;
+	}
+	/**
+	* Statement to add a new column to a specified table.
+	*
+	* @param columnTable - The name of the table to which the column will be added.
+	* @param entry - The column definition including the column name and its data type. See {@link columnDefinition()}
+	* @return The SQL statement as a string.
+	*/
+	createColumn(columnTable, entry) {
+		return `ALTER TABLE ${this.formatIdentifier(columnTable)} ADD ${entry};`;
+	}
+	/**
+	* Statement to rename a column in an existing table.
+	*
+	* @param tableName - The name of the table containing the column to rename.
+	* @param oldColumnName - The current name of the column to be renamed.
+	* @param newColumnName - The new name for the column.
+	* @return The SQL statement as a string.
+	*/
+	renameColumn(tableName, oldColumnName, 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.
+	*
+	* @param tableName - The name of the table from which the column will be dropped.
+	* @param columnName - The name of the column to be dropped.
+	* @return The SQL statement as a string.
+	*/
+	dropColumn(tableName, columnName) {
+		return `ALTER TABLE ${this.formatIdentifier(tableName)} DROP COLUMN ${this.formatIdentifier(columnName)};`;
+	}
+	/**
+	* Statement to return data from a table.
+	*
+	* @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, 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.
+	*
+	* @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}`);
+		return !!(await this.db.runReadStatement(query)).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 escapeStringFu = escapeString.default ?? escapeString;
+		const downChanges = escapeStringFu(changes.down);
+		const upChanges = escapeStringFu(changes.up);
+		const query = `${this.migrationTableQuery()} ${await this.hasChanges(toVersion) ? `UPDATE ${MIGRATION_DATA_TABLE_NAME}
 				SET
 				    ${this.formatIdentifier("fromVersion")} = '${fromVersion}',
 			   	    ${this.formatIdentifier("upChanges")} = ${upChanges},
@@ -794,725 +774,656 @@ var DefaultSql = class {
 					${this.formatIdentifier("downChanges")}
 				)
 				VALUES ('${fromVersion}', '${toVersion}', ${upChanges}, ${downChanges})`}`;
-    await this.db.runTransaction(query);
-  }
+		await this.db.runTransaction(query);
+	}
 };
-// src/lib/MigrationManager.ts
+//#endregion
+//#region src/lib/MigrationManager.ts
+/**
+* The MigrationManager class is responsible for managing database schema migrations.
+* It handles tasks such as generating SQL for migrations, creating migration histories,
+* and synchronizing database schema changes between different versions.
+*/
 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 columnInfoEntries - An array of ColumnInfo objects containing details about each column.
-   * @return The name of the primary key column if found; otherwise, undefined.
-   */
-  getPrimaryKeyColumn(columnInfoEntries) {
-    for (const key in columnInfoEntries) {
-      const columnInfo = columnInfoEntries[key];
-      if (columnInfo.isPrimaryKey)
-        return columnInfo.name;
-    }
-  }
-  /**
-   * 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;
-  }
+	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 += `\n\n-- Custom SQL from preMigration()\n${preSQL.up}`;
+			changes.down += `\n\n-- Custom SQL from preMigration()\n${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 += `\n\n-- Custom SQL from postMigration()\n${postSql.up}`;
+			changes.down += `\n\n-- Custom SQL from postMigration()\n${postSql.down}`;
+		}
+		if (fromVersion != 0) {
+			const exception = this.migrations.verifyRenamingTasks(this.newTables) ?? this.migrations.verifyAllowedMigrations();
+			if (exception) {
+				Logger.debug(`\nCanceled changes:\n${changes.up}\n`);
+				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)}\n`;
+			changes.down += `${this.dialect.dropTable(tableName)}\n`;
+		}
+		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)}\n`;
+			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) {
+			if (!migrationData[tableName].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 moveDataQuery = this.dialect.insert(backupTableName, this.dialect.insertValues(moveableColumns, this.dialect.select(tableName, moveableColumns))) + "\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) {
+				if (oldForeignKeys.find((entry) => entry.fromColumn == newForeignKey.fromColumn)) 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];
+				if (renamedColumns?.find((entry) => entry.newName)) 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];
+				if (newColumnList[this.migrations.getNewestColumnName(tableName, oldColumn.name)] == 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 columnInfoEntries - An array of ColumnInfo objects containing details about each column.
+	* @return The name of the primary key column if found; otherwise, undefined.
+	*/
+	getPrimaryKeyColumn(columnInfoEntries) {
+		for (const key in columnInfoEntries) {
+			const columnInfo = columnInfoEntries[key];
+			if (columnInfo.isPrimaryKey) return columnInfo.name;
+		}
+	}
+	/**
+	* 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/tableInfo/decorators/TableClass.ts
-import "polyfill-symbol-metadata";
+//#endregion
+//#region src/lib/tableInfo/decorators/TableClass.ts
+/**
+* Decorator function to configure a database table with its name and primary key.
+*
+* @param tableName - The name of the database table used in SQL.
+* @param primaryKey - The property name representing the primary property of the table.
+*/
 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 });
-  };
+	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);
-      }
-    }
-  }
-  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}`);
-      }
-    }
-  }
-  /**
-   * Creates a foreign key relationship between the current table and a target table.
-   *
-   * @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.
-   */
-  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;
-  }
-  /**
-   * 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
-   */
-  sealType() {
-    return this;
-  }
-  static create(tableName, columns) {
-    return new _TableObj(tableName, columns);
-  }
+//#endregion
+//#region src/lib/tableInfo/TableObj.ts
+/**
+* Use this class to define tables for DatabaseInstructions
+* (as an alternative for Class decorators)
+*
+*/
+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);
+		}
+	}
+	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}`);
+			}
+		}
+	}
+	/**
+	* Creates a foreign key relationship between the current table and a target table.
+	*
+	* @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.
+	*/
+	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;
+	}
+	/**
+	* 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
+	*/
+	sealType() {
+		return this;
+	}
+	static create(tableName, columns) {
+		return new TableObj(tableName, columns);
+	}
 };
-// src/lib/tableInfo/decorators/DataType.ts
-import "polyfill-symbol-metadata";
+//#endregion
+//#region src/lib/tableInfo/decorators/DataType.ts
+/**
+* Decorator function to assign a specific data type to a column.
+* Should be used if you want to use a data type that does not exist in JavaScript or
+* if the default value should be NULL
+*
+* @param type - The data type to be assigned.
+*/
 function DataType(type) {
-  return (table, context) => {
-    const entry = getInputColumnInfo(table, context);
-    entry.inputType = type;
-  };
+	return (table, context) => {
+		const entry = getInputColumnInfo(table, context);
+		entry.inputType = type;
+	};
 }
-// src/lib/tableInfo/decorators/ForeignKey.ts
-import "polyfill-symbol-metadata";
+//#endregion
+//#region src/lib/tableInfo/decorators/ForeignKey.ts
+/**
+* Decorator function to define a foreign key relationship for a database table.
+*
+* @param toTable - The target table class to which the foreign key points.
+* @param toColumn - The column name in the target table to which the foreign key points.
+* @param options - Additional options.
+*/
 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
-    });
-  };
+	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,
+			toTable: toTable.name,
+			toColumn: toColumn.toString(),
+			onDelete: options?.onDelete,
+			onUpdate: options?.onUpdate
+		});
+	};
 }
-// src/lib/dialects/SqliteDialect.ts
+//#endregion
+//#region src/lib/dialects/SqliteDialect.ts
+/**
+* SQLite-specific syntax for SQL queries
+*/
 var SqliteDialect = class extends DefaultSql {
-  types = {
-    text: "TEXT",
-    string: "TEXT",
-    number: "INTEGER",
-    bigint: "INTEGER",
-    boolean: "INTEGER",
-    date: "INTEGER",
-    time: "INTEGER",
-    dateTime: "INTEGER"
-  };
-  canRecreateTable = true;
-  canAlterColumnStructure = false;
-  canAlterForeignKeys = false;
-  canAlterPrimaryKey = false;
-  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.runReadStatement("SELECT name FROM sqlite_master WHERE type = 'table'")).map((obj) => obj.name);
-  }
-  async getColumnInformation(tableName) {
-    const data = await this.db.runReadStatement(`PRAGMA table_info(${tableName})`);
-    const output = {};
-    for (const entry of data) {
-      output[entry["name"]] = {
-        name: entry["name"],
-        sqlType: entry["type"],
-        defaultValue: entry["dflt_value"] ?? this.nullType,
-        isPrimaryKey: entry["pk"] == "1"
-      };
-    }
-    return output;
-  }
-  formatValueToSql(value, type) {
-    function toDate(value2) {
-      return value2 instanceof Date ? value2 : new Date(value2);
-    }
-    switch (type) {
-      case "boolean":
-        return value ? "1" : "0";
-      case "date":
-      case "time":
-      case "dateTime":
-        return toDate(value).getTime().toString();
-      default:
-        return super.formatValueToSql(value, type);
-    }
-  }
-  async getForeignKeys(tableName) {
-    const data = await this.db.runReadStatement(`PRAGMA foreign_key_list(${tableName});`);
-    return data.map((entry) => {
-      return {
-        fromTable: tableName,
-        fromColumn: entry["from"],
-        toTable: entry["table"],
-        toColumn: entry["to"],
-        onUpdate: entry["on_update"] ?? "NO ACTION",
-        onDelete: entry["on_delete"] ?? "NO ACTION"
-      };
-    });
-  }
-  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.runReadStatement(`PRAGMA user_version;`);
-    return output[0].user_version;
-  }
-  async rollbackHistory(toVersion) {
-    await this.db.runTransaction(`PRAGMA user_version = ${toVersion};`);
-    await super.rollbackHistory(toVersion);
-  }
+	types = {
+		text: "TEXT",
+		string: "TEXT",
+		number: "INTEGER",
+		bigint: "INTEGER",
+		boolean: "INTEGER",
+		date: "INTEGER",
+		time: "INTEGER",
+		dateTime: "INTEGER"
+	};
+	canRecreateTable = true;
+	canAlterColumnStructure = false;
+	canAlterForeignKeys = false;
+	canAlterPrimaryKey = false;
+	formatIdentifier(identifier) {
+		return `"${identifier}"`;
+	}
+	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.runReadStatement("SELECT name FROM sqlite_master WHERE type = 'table'")).map((obj) => obj.name);
+	}
+	async getColumnInformation(tableName) {
+		const data = await this.db.runReadStatement(`PRAGMA table_info(${tableName})`);
+		const output = {};
+		for (const entry of data) output[entry["name"]] = {
+			name: entry["name"],
+			sqlType: entry["type"],
+			defaultValue: entry["dflt_value"] ?? this.nullType,
+			isPrimaryKey: entry["pk"] == "1"
+		};
+		return output;
+	}
+	formatValueToSql(value, type) {
+		function toDate(value) {
+			return value instanceof Date ? value : new Date(value);
+		}
+		switch (type) {
+			case "boolean": return value ? "1" : "0";
+			case "date":
+			case "time":
+			case "dateTime": return toDate(value).getTime().toString();
+			default: return super.formatValueToSql(value, type);
+		}
+	}
+	async getForeignKeys(tableName) {
+		return (await this.db.runReadStatement(`PRAGMA foreign_key_list(${tableName});`)).map((entry) => {
+			return {
+				fromTable: tableName,
+				fromColumn: entry["from"],
+				toTable: entry["table"],
+				toColumn: entry["to"],
+				onUpdate: entry["on_update"] ?? "NO ACTION",
+				onDelete: entry["on_delete"] ?? "NO ACTION"
+			};
+		});
+	}
+	async setChanges(fromVersion, toVersion, changes) {
+		await this.db.runTransaction(`PRAGMA user_version = ${toVersion};`);
+		await super.setChanges(fromVersion, toVersion, changes);
+	}
+	async getVersion() {
+		return (await this.db.runReadStatement(`PRAGMA user_version;`))[0].user_version;
+	}
+	async rollbackHistory(toVersion) {
+		await this.db.runTransaction(`PRAGMA user_version = ${toVersion};`);
+		await super.rollbackHistory(toVersion);
+	}
 };
-// src/lib/dialects/PostgresDialect.ts
+//#endregion
+//#region src/lib/dialects/PostgresDialect.ts
 var PostgresDialect = class extends DefaultSql {
-  canRecreateTable = false;
-  canAlterColumnStructure = true;
-  canAlterForeignKeys = true;
-  canAlterPrimaryKey = true;
-  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 ${this.formatIdentifier(fromTableName)} ADD CONSTRAINT ${this.formatIdentifier(fromTableName)} ${foreignKey};`;
-  }
-  removeForeignKey(tableName, foreignKeyName) {
-    return `ALTER TABLE ${this.formatIdentifier(tableName)} DROP CONSTRAINT ${foreignKeyName};`;
-  }
-  async getTableNames() {
-    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.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) {
-      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"],
-        sqlType: dataType,
-        defaultValue: defaultValue ? `'${defaultValue[1]}'` : entry["column_default"] ?? this.nullType,
-        isPrimaryKey: entry["constraint_type"] == "PRIMARY KEY"
-      };
-    }
-    return output;
-  }
-  addPrimaryKey(tableName, columnName) {
-    return `ALTER TABLE ${tableName} ADD PRIMARY KEY (${columnName});
-`;
-  }
-  removePrimaryKey(tableName, columnName) {
-    return `ALTER TABLE ${tableName} DROP CONSTRAINT ${columnName};
-`;
-  }
-  async getForeignKeys(tableName) {
-    const data = await this.db.runReadStatement(
-      `SELECT
+	canRecreateTable = false;
+	canAlterColumnStructure = true;
+	canAlterForeignKeys = true;
+	canAlterPrimaryKey = true;
+	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 ${this.formatIdentifier(fromTableName)} ADD CONSTRAINT ${this.formatIdentifier(fromTableName)} ${foreignKey};`;
+	}
+	removeForeignKey(tableName, foreignKeyName) {
+		return `ALTER TABLE ${this.formatIdentifier(tableName)} DROP CONSTRAINT ${foreignKeyName};`;
+	}
+	async getTableNames() {
+		return (await this.db.runReadStatement("SELECT table_name FROM information_schema.tables WHERE table_schema='public' AND table_type='BASE TABLE';")).map((row) => row.table_name);
+	}
+	async getColumnInformation(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) {
+			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;
+			}
+			output[entry["column_name"]] = {
+				name: entry["column_name"],
+				sqlType: dataType,
+				defaultValue: defaultValue ? `'${defaultValue[1]}'` : entry["column_default"] ?? this.nullType,
+				isPrimaryKey: entry["constraint_type"] == "PRIMARY KEY"
+			};
+		}
+		return output;
+	}
+	addPrimaryKey(tableName, columnName) {
+		return `ALTER TABLE ${tableName} ADD PRIMARY KEY (${columnName});\n`;
+	}
+	removePrimaryKey(tableName, columnName) {
+		return `ALTER TABLE ${tableName} DROP CONSTRAINT ${columnName};\n`;
+	}
+	async getForeignKeys(tableName) {
+		return (await this.db.runReadStatement(`SELECT
 				tc.table_name AS child_table,
 				kcu.column_name AS child_column,
                 ccu.table_name AS parent_table,
@@ -1526,177 +1437,157 @@ var PostgresDialect = class extends DefaultSql {
 					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: tableName,
-        fromColumn: entry["child_column"],
-        toTable: entry["parent_table"],
-        toColumn: entry["parent_column"],
-        onUpdate: entry["update_rule"],
-        onDelete: entry["delete_rule"]
-      };
-    });
-  }
+			WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = '${tableName}';`)).map((entry) => {
+			return {
+				fromTable: tableName,
+				fromColumn: entry["child_column"],
+				toTable: entry["parent_table"],
+				toColumn: entry["parent_column"],
+				onUpdate: entry["update_rule"],
+				onDelete: entry["delete_rule"]
+			};
+		});
+	}
 };
-// src/lib/dialects/MySqlDialect.ts
+//#endregion
+//#region src/lib/dialects/MySqlDialect.ts
 var MySqlDialect = class extends DefaultSql {
-  canRecreateTable = true;
-  canAlterColumnStructure = true;
-  canAlterForeignKeys = true;
-  canAlterPrimaryKey = true;
-  types = {
-    text: "TEXT",
-    string: "VARCHAR",
-    number: "INT",
-    bigint: "BIGINT",
-    boolean: "TINYINT(1)",
-    date: "DATE",
-    time: "TIME",
-    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 ?? 100})`;
-      default:
-        return super.getSqlType(dataType, columnInfo);
-    }
-  }
-  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};`;
-  }
-  removeForeignKey(tableName, foreignKeyName) {
-    return `ALTER TABLE ${tableName} DROP FOREIGN KEY ${foreignKeyName};`;
-  }
-  addPrimaryKey(tableName, columnName) {
-    return `ALTER TABLE ${tableName} PRIMARY KEY (${columnName});`;
-  }
-  removePrimaryKey(tableName, _columnName) {
-    return `ALTER TABLE ${tableName} PRIMARY KEY;`;
-  }
-  async getForeignKeys(tableName) {
-    const data = await this.db.runReadStatement(
-      `SELECT
+	canRecreateTable = true;
+	canAlterColumnStructure = true;
+	canAlterForeignKeys = true;
+	canAlterPrimaryKey = true;
+	types = {
+		text: "TEXT",
+		string: "VARCHAR",
+		number: "INT",
+		bigint: "BIGINT",
+		boolean: "TINYINT(1)",
+		date: "DATE",
+		time: "TIME",
+		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 ?? 100})`;
+			default: return super.getSqlType(dataType, columnInfo);
+		}
+	}
+	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};`;
+	}
+	removeForeignKey(tableName, foreignKeyName) {
+		return `ALTER TABLE ${tableName} DROP FOREIGN KEY ${foreignKeyName};`;
+	}
+	addPrimaryKey(tableName, columnName) {
+		return `ALTER TABLE ${tableName} PRIMARY KEY (${columnName});`;
+	}
+	removePrimaryKey(tableName, _columnName) {
+		return `ALTER TABLE ${tableName} PRIMARY KEY;`;
+	}
+	async getForeignKeys(tableName) {
+		return (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"],
-        onUpdate: entry["UPDATE_RULE"],
-        onDelete: entry["DELETE_RULE"]
-      };
-    });
-  }
-  async getTableNames() {
-    const entries = await this.db.runReadStatement("SHOW TABLES");
-    return entries.map((entry) => Object.values(entry)[0]);
-  }
-  async getColumnInformation(tableName) {
-    const data = await this.db.runReadStatement(`SHOW COLUMNS FROM ${tableName};`);
-    const output = {};
-    for (const entry of data) {
-      const sqlType = entry["Type"].toUpperCase();
-      const info = {
-        name: entry["Field"],
-        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;
-  }
+			WHERE info.REFERENCED_TABLE_SCHEMA = (SELECT DATABASE()) AND info.TABLE_NAME = '${tableName}';`)).map((entry) => {
+			return {
+				fromTable: tableName,
+				fromColumn: entry["COLUMN_NAME"],
+				toTable: entry["REFERENCED_TABLE_NAME"],
+				toColumn: entry["REFERENCED_COLUMN_NAME"],
+				onUpdate: entry["UPDATE_RULE"],
+				onDelete: entry["DELETE_RULE"]
+			};
+		});
+	}
+	async getTableNames() {
+		return (await this.db.runReadStatement("SHOW TABLES")).map((entry) => Object.values(entry)[0]);
+	}
+	async getColumnInformation(tableName) {
+		const data = await this.db.runReadStatement(`SHOW COLUMNS FROM ${tableName};`);
+		const output = {};
+		for (const entry of data) {
+			const sqlType = entry["Type"].toUpperCase();
+			const info = {
+				name: entry["Field"],
+				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
+//#endregion
+//#region src/lib/getDialect.ts
 function getDialect(db, dialect) {
-  switch (dialect) {
-    case "Sqlite":
-      return new SqliteDialect(db);
-    case "Postgres":
-      return new PostgresDialect(db);
-    case "MySql":
-      return new MySqlDialect(db);
-    default:
-      throw new Error(`Unknown dialect ${dialect}`);
-  }
+	switch (dialect) {
+		case "Sqlite": return new SqliteDialect(db);
+		case "Postgres": return new PostgresDialect(db);
+		case "MySql": return new MySqlDialect(db);
+		default: throw new Error(`Unknown dialect ${dialect}`);
+	}
 }
-// src/index.ts
+//#endregion
+//#region src/index.ts
 async function runMigration(db, dbInstructions) {
-  Logger.setMode(dbInstructions.loggerMode);
-  const dialect = getDialect(db, dbInstructions.dialect);
-  const mm = new MigrationManager(dialect);
-  const migration = await mm.generateSqlChanges(dbInstructions);
-  if (migration) {
-    await dialect.setChanges(migration.fromVersion, dbInstructions.version, migration.changes);
-    await db.createBackup?.(`from_${migration.fromVersion}_to_${dbInstructions.version}`);
-    await dialect.runTransactionWithoutForeignKeys(migration.changes.up);
-  }
+	Logger.setMode(dbInstructions.loggerMode);
+	const dialect = getDialect(db, dbInstructions.dialect);
+	const migration = await new MigrationManager(dialect).generateSqlChanges(dbInstructions);
+	if (migration) {
+		await db.createBackup?.(`from_${migration.fromVersion}_to_${dbInstructions.version}`);
+		await dialect.runTransactionWithoutForeignKeys(migration.changes.up);
+		await dialect.setChanges(migration.fromVersion, dbInstructions.version, migration.changes);
+	}
 }
+/**
+* Rolls back the database to the provided toVersion
+* @param dbAccess - Access to the database.
+* @param toVersion - the version to which the database should be upgraded to.
+* @param dialect - the dialect that should be used for the database. Usually is the value defined in DatabaseInstructions
+* @param loggerMode - defines how much should be logged to the console.
+*/
 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}`);
-  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 sql.rollbackHistory(version);
-  return version;
+	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}`);
+	let version = fromVersion;
+	while (version > toVersion) {
+		const changes = await sql.getChanges(version);
+		if (!changes) throw new Error(`Unexpected error! No changes were found from version ${version} (fromVersion: ${fromVersion}, toVersion: ${toVersion})`);
+		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 sql.rollbackHistory(version);
+	return version;
 }
-export {
-  DataType,
-  ForeignKey,
-  TableClass,
-  TableObj,
-  rollback,
-  runMigration
-};
+//#endregion
+export { DataType, ForeignKey, TableClass, TableObj, rollback, runMigration };