sqlmorpheus 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,1861 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let escape_sql_string = require("escape-sql-string");
+escape_sql_string = __toESM(escape_sql_string, 1);
+require("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}`);
+	}
+};
+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
+		};
+	}
+};
+//#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];
+}
+/**
+* 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);
+}
+/**
+* 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];
+}
+//#endregion
+//#region src/lib/TableStructureGenerator.ts
+/**
+* Postgres silently truncates longer identifiers, which would lead to differing index names in each migration
+*/
+const MAX_INDEX_NAME_LENGTH = 63;
+/**
+* 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 = {};
+		const indexNames = {};
+		for (const table of this.dbInstructions.tables) {
+			let structure;
+			let tableName;
+			if (TableObjHelper.isTableObj(table)) {
+				structure = table.tableStructure;
+				tableName = table.tableName;
+			} else {
+				const classTable = table;
+				structure = getTableStructure(classTable);
+				tableName = classTable.name;
+			}
+			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);
+			}
+			const indexes = this.getIndexes(tableName, structure);
+			for (const index of indexes) {
+				if (indexNames[index.name]) throw new Error(`Index name "${index.name}" is used in ${indexNames[index.name]} and ${tableName}. Index names need to be unique.`);
+				indexNames[index.name] = tableName;
+			}
+			tables[tableName] = {
+				...structure,
+				indexes
+			};
+		}
+		return tables;
+	}
+	/**
+	* Validates the index definitions of a table and generates names for indexes that have none.
+	*
+	* @param tableName - The name of the table the indexes belong to.
+	* @param structure - The table structure containing the index definitions.
+	* @return The index definitions including their names.
+	*/
+	getIndexes(tableName, structure) {
+		return (structure.indexes ?? []).map((index) => {
+			if (!index.columns.length) throw new Error(`An index in ${tableName} has no columns.`);
+			for (const column of index.columns) if (!structure.columns[column]) throw new Error(`Index in ${tableName} uses column "${column}", which does not exist.`);
+			const name = index.name ?? `${tableName}_${index.columns.join("_")}_idx`;
+			if (name.length > MAX_INDEX_NAME_LENGTH) throw new Error(`Index name "${name}" is longer than ${MAX_INDEX_NAME_LENGTH} characters. Please provide a shorter name.`);
+			return {
+				name,
+				columns: index.columns,
+				isUnique: index.isUnique
+			};
+		});
+	}
+};
+//#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 += `\t\tmigrations.allowMigration(${entry.version}, "${entry.tableName}", "${entry.type.toString()}"${entry.column != "noColumn" ? `, "${entry.column}"` : ""});\n`;
+		super(message);
+	}
+};
+//#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 /* @__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".
+	* For "dropIndex", the index name is used instead.
+	*/
+	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".
+	* For "dropIndex", provide the index name instead.
+	*
+	* @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.`);
+			case "dropIndex": throw new Error(`The ${allowedMigration} migration requires an index 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");
+	}
+};
+//#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(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 create an index on a specified table.
+	*
+	* @param tableName - The name of the table on which the index will be created.
+	* @param index - The index definition.
+	* @return The SQL statement as a string.
+	*/
+	createIndex(tableName, index) {
+		return `CREATE ${index.isUnique ? "UNIQUE " : ""}INDEX ${this.formatIdentifier(index.name)} ON ${this.formatIdentifier(tableName)} (${index.columns.map((column) => this.formatIdentifier(column)).join(", ")});`;
+	}
+	/**
+	* Statement to drop an index from a specified table.
+	*
+	* @param tableName - The name of the table the index belongs to.
+	* @param indexName - The name of the index to be dropped.
+	* @return The SQL statement as a string.
+	*/
+	dropIndex(tableName, indexName) {
+		return `DROP INDEX ${this.formatIdentifier(indexName)};`;
+	}
+	/**
+	* 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)
+		]);
+	}
+	/**
+	* Combines rows (one row per indexed column, ordered by index name and column position) into a list of {@link IndexInfo}.
+	*
+	* @param rows - Rows containing the index name, whether the index is unique and the column name.
+	* @return An array of {@link IndexInfo}.
+	*/
+	rowsToIndexInfo(rows) {
+		const indexes = {};
+		for (const row of rows) {
+			if (!indexes[row.index_name]) indexes[row.index_name] = {
+				name: row.index_name,
+				columns: [],
+				isUnique: !!Number(row.is_unique)
+			};
+			indexes[row.index_name].columns.push(row.column_name);
+		}
+		return Object.values(indexes);
+	}
+	/**
+	* 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 = escape_sql_string.default.default ?? escape_sql_string.default;
+		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},
+			   	    ${this.formatIdentifier("downChanges")} = ${downChanges}
+			   	WHERE ${this.formatIdentifier("toVersion")} = '${toVersion}';` : `INSERT INTO ${MIGRATION_DATA_TABLE_NAME} (
+					${this.formatIdentifier("fromVersion")},
+    				${this.formatIdentifier("toVersion")},
+					${this.formatIdentifier("upChanges")},
+					${this.formatIdentifier("downChanges")}
+				)
+				VALUES ('${fromVersion}', '${toVersion}', ${upChanges}, ${downChanges})`}`;
+		await this.db.runTransaction(query);
+	}
+};
+//#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 += `\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));
+			const renameTablesChanges = this.renameTables();
+			const createAndDropTablesChanges = await this.createAndDropTables();
+			const foreignKeyChanges = await this.migrateForeignKeys();
+			const columnChanges = await this.migrateColumns();
+			const renameColumnsChanges = this.renameColumns();
+			const indexChanges = await this.migrateIndexes();
+			const recreateTablesChanges = await this.recreateTables();
+			[
+				renameTablesChanges,
+				createAndDropTablesChanges,
+				indexChanges.dropped,
+				foreignKeyChanges,
+				columnChanges,
+				renameColumnsChanges,
+				indexChanges.created,
+				recreateTablesChanges
+			].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.up += this.createIndexesSql(tableName, structure.indexes);
+			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)) + "\n" + this.createIndexesSql(tableName, await this.dialect.getIndexes(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);
+	}
+	/**
+	* Generates an SQL string to create all provided indexes on a table.
+	*
+	* @param tableName - The name of the table the indexes belong to.
+	* @param indexes - The index definitions.
+	* @return The SQL string to create the indexes (one statement per line).
+	*/
+	createIndexesSql(tableName, indexes) {
+		return (indexes ?? []).map((index) => `${this.dialect.createIndex(tableName, index)}\n`).join("");
+	}
+	/**
+	* 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" + this.createIndexesSql(tableName, structure.indexes) + "\n";
+			const dbTableName = this.migrations.getOldTableName(tableName);
+			changes.down += this.createTableSql(backupTableName, await this.dialect.getColumnInformation(dbTableName), await this.dialect.getForeignKeys(dbTableName)) + "\n" + moveDataQuery + "\n" + this.createIndexesSql(tableName, await this.dialect.getIndexes(dbTableName));
+		}
+		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;
+	}
+	/**
+	* Compares the indexes of all existing tables with their new definitions.
+	* Indexes that are removed or changed have to be allowed (using "dropIndex").
+	* Indexes of tables that will be recreated are only checked, their SQL is generated in {@link recreateTables()}.
+	*
+	* @return SQL changes to drop indexes (needs to run before columns are migrated)
+	* and to create indexes (needs to run after columns were migrated and renamed).
+	*/
+	async migrateIndexes() {
+		const dropped = {
+			up: "\n\n-- Drop indexes\n",
+			down: "\n\n-- Drop indexes\n"
+		};
+		const created = {
+			up: "\n\n-- Create indexes\n",
+			down: "\n\n-- Create indexes\n"
+		};
+		for (const tableName in this.newTables) {
+			if (this.tableDoesNotExists(tableName)) continue;
+			const dbTableName = this.migrations.getOldTableName(tableName);
+			const newIndexes = this.newTables[tableName].indexes ?? [];
+			const oldIndexes = await this.dialect.getIndexes(dbTableName);
+			const isSameIndex = (oldIndex, newIndex) => oldIndex.isUnique == newIndex.isUnique && oldIndex.columns.length == newIndex.columns.length && oldIndex.columns.every((column, i) => this.migrations.getNewestColumnName(tableName, column) == newIndex.columns[i]);
+			const indexesToDrop = [];
+			const indexesToCreate = [];
+			const addedIndexes = newIndexes.filter((newIndex) => !oldIndexes.some((oldIndex) => oldIndex.name == newIndex.name));
+			for (const oldIndex of oldIndexes) {
+				const newIndex = newIndexes.find((entry) => entry.name == oldIndex.name);
+				if (newIndex) {
+					if (isSameIndex(oldIndex, newIndex)) continue;
+					Logger.log(`Index ${oldIndex.name} in ${tableName} will be changed!`);
+					this.migrations.compareWithAllowedMigration(tableName, "dropIndex", oldIndex.name);
+					indexesToCreate.push(newIndex);
+				} else {
+					const renamedIndex = addedIndexes.find((entry) => isSameIndex(oldIndex, entry));
+					if (renamedIndex) {
+						Logger.log(`Index ${oldIndex.name} in ${tableName} will be renamed to ${renamedIndex.name}!`);
+						addedIndexes.splice(addedIndexes.indexOf(renamedIndex), 1);
+						indexesToCreate.push(renamedIndex);
+					} else {
+						Logger.log(`Index ${oldIndex.name} in ${tableName} will be removed!`);
+						this.migrations.compareWithAllowedMigration(tableName, "dropIndex", oldIndex.name);
+					}
+				}
+				indexesToDrop.push(oldIndex);
+			}
+			for (const newIndex of addedIndexes) {
+				Logger.log(`Index ${newIndex.name} in ${tableName} will be added!`);
+				indexesToCreate.push(newIndex);
+			}
+			if (this.migrations.willBeRecreated(tableName)) continue;
+			for (const index of indexesToDrop) {
+				dropped.up += `${this.dialect.dropIndex(tableName, index.name)}\n`;
+				created.down += `${this.dialect.createIndex(dbTableName, index)}\n`;
+			}
+			for (const index of indexesToCreate) {
+				created.up += `${this.dialect.createIndex(tableName, index)}\n`;
+				dropped.down += `${this.dialect.dropIndex(dbTableName, index.name)}\n`;
+			}
+		}
+		return {
+			dropped,
+			created
+		};
+	}
+	/**
+	* 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;
+	}
+};
+//#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
+		});
+	};
+}
+//#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: [],
+		indexes: []
+	};
+	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;
+	}
+	/**
+	* Creates an index on one or more columns of the current table.
+	*
+	* @param columns - The columns that will be part of the index (in order).
+	* @param options - Optional configurations for the index.
+	* If no name is provided, the name is generated from the table and column names.
+	*/
+	index(columns, options) {
+		this.tableStructure.indexes.push({
+			name: options?.name,
+			columns: columns.map((column) => column.toString()),
+			isUnique: !!options?.unique
+		});
+		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/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;
+	};
+}
+//#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,
+			toTable: toTable.name,
+			toColumn: toColumn.toString(),
+			onDelete: options?.onDelete,
+			onUpdate: options?.onUpdate
+		});
+	};
+}
+//#endregion
+//#region src/lib/tableInfo/decorators/Index.ts
+/**
+* Decorator function to create an index on one or more columns of a table.
+* This decorator must be used at the head of the class.
+*
+* @param columns - The columns that will be part of the index (in order).
+* @param options - Additional options. If no name is provided, the name is generated from the table and column names.
+*/
+function Index(columns, options) {
+	return (table, context) => {
+		const tableInfo = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(table);
+		if (!tableInfo.indexes) tableInfo.indexes = [];
+		tableInfo.indexes.push({
+			name: options?.name,
+			columns: columns.map((column) => column.toString()),
+			isUnique: !!options?.unique
+		});
+	};
+}
+//#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;
+	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 getIndexes(tableName) {
+		const data = await this.db.runReadStatement(`SELECT il.name AS index_name, il."unique" AS is_unique, ii.name AS column_name
+			FROM pragma_index_list('${tableName}') AS il JOIN pragma_index_info(il.name) AS ii
+			WHERE il.origin = 'c'
+			ORDER BY il.name, ii.seqno;`);
+		return this.rowsToIndexInfo(data);
+	}
+	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);
+	}
+};
+//#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() {
+		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 getIndexes(tableName) {
+		const data = await this.db.runReadStatement(`SELECT i.relname AS index_name, ix.indisunique AS is_unique, a.attname AS column_name
+			FROM pg_index AS ix
+				JOIN pg_class AS t ON t.oid = ix.indrelid
+				JOIN pg_class AS i ON i.oid = ix.indexrelid
+				JOIN pg_namespace AS n ON n.oid = t.relnamespace
+				JOIN pg_attribute AS a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+			WHERE n.nspname = 'public' AND t.relname = '${tableName}' AND NOT ix.indisprimary
+				AND NOT EXISTS (SELECT 1 FROM pg_constraint AS c WHERE c.conindid = ix.indexrelid)
+			ORDER BY i.relname, array_position(ix.indkey::int2[], a.attnum);`);
+		return this.rowsToIndexInfo(data);
+	}
+	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,
+				ccu.column_name AS parent_column,
+				rc.update_rule AS update_rule,
+				rc.delete_rule AS delete_rule
+			FROM information_schema.table_constraints AS tc
+				JOIN information_schema.key_column_usage AS kcu
+					ON tc.constraint_name = kcu.constraint_name
+				JOIN information_schema.constraint_column_usage AS ccu
+					ON tc.constraint_name = ccu.constraint_name
+                JOIN information_schema.referential_constraints AS rc
+                     ON tc.constraint_name=rc.constraint_name
+			WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = '${tableName}';`)).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"]
+			};
+		});
+	}
+};
+//#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) {
+		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}';`)).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"]
+			};
+		});
+	}
+	dropIndex(tableName, indexName) {
+		return `DROP INDEX ${this.formatIdentifier(indexName)} ON ${this.formatIdentifier(tableName)};`;
+	}
+	async getIndexes(tableName) {
+		const data = await this.db.runReadStatement(`SELECT s.INDEX_NAME AS index_name, s.NON_UNIQUE = 0 AS is_unique, s.COLUMN_NAME AS column_name
+			FROM information_schema.STATISTICS AS s
+			WHERE s.TABLE_SCHEMA = (SELECT DATABASE()) AND s.TABLE_NAME = '${tableName}' AND s.INDEX_NAME <> 'PRIMARY'
+				AND NOT EXISTS (
+					SELECT 1 FROM information_schema.KEY_COLUMN_USAGE AS k
+					WHERE k.TABLE_SCHEMA = s.TABLE_SCHEMA AND k.TABLE_NAME = s.TABLE_NAME AND k.REFERENCED_TABLE_NAME IS NOT NULL
+						AND (k.CONSTRAINT_NAME = s.INDEX_NAME OR k.COLUMN_NAME = s.INDEX_NAME)
+				)
+			ORDER BY s.INDEX_NAME, s.SEQ_IN_INDEX;`);
+		return this.rowsToIndexInfo(data);
+	}
+	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;
+	}
+};
+//#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}`);
+	}
+}
+//#endregion
+//#region src/index.ts
+/**
+* Executes a database migration based on the provided database connection and migration instructions.
+*
+* @param db - The database access object used to interact with the database.
+* @param dbInstructions - The migration instructions, including target version, logger mode, and dialect.
+* @return A promise that resolves when the migration process is successfully completed.
+*/
+async function runMigration(db, dbInstructions) {
+	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(`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;
+}
+//#endregion
+exports.DataType = DataType;
+exports.ForeignKey = ForeignKey;
+exports.Index = Index;
+exports.TableClass = TableClass;
+exports.TableObj = TableObj;
+exports.rollback = rollback;
+exports.runMigration = runMigration;