sqlmorpheus 0.1.10 → 0.2.1

package/dist/index.mjs

@@ -37,6 +37,47 @@ function getTableInfoFromMetadata(metadata) {
   return metadata[TABLE_INFO_PROPERTY_NAME];
 }
 
+// src/lib/tableInfo/TableObj.ts
+var TableObj = class _TableObj {
+  IS_TABLE_OBJ = true;
+  tableName;
+  columns;
+  tableInfo = {
+    primaryKey: void 0,
+    foreignKeys: [],
+    dataTypes: {}
+  };
+  constructor(tableName, columns) {
+    this.tableName = tableName;
+    this.columns = columns;
+  }
+  primaryKey(key) {
+    this.tableInfo.primaryKey = key.toString();
+    return this;
+  }
+  foreignKey(fromColumn, toTable, toColumn, options) {
+    this.tableInfo.foreignKeys.push({
+      fromTable: this.tableName,
+      fromColumn: fromColumn.toString(),
+      toTable: toTable.tableName,
+      toColumn: toColumn.toString(),
+      onUpdate: options?.onUpdate,
+      onDelete: options?.onDelete
+    });
+    return this;
+  }
+  dataType(column, type) {
+    this.tableInfo.dataTypes[column.toString()] = type;
+    return this;
+  }
+  static create(tableName, columns) {
+    return new _TableObj(tableName, columns);
+  }
+  static isDbTable(obj) {
+    return !!obj?.IS_TABLE_OBJ;
+  }
+};
+
 // src/lib/TableStructureGenerator.ts
 var TableStructureGenerator = class {
   dialect;
@@ -45,19 +86,21 @@ var TableStructureGenerator = class {
     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() {
-    if (this.dbInstructions.tables.length) {
-      const tableObjects = {};
-      for (const table of this.dbInstructions.tables) {
-        tableObjects[table.name] = { columns: new table(), tableInfo: getTableInfo(table) };
+    const tableObjects = {};
+    for (const table of this.dbInstructions.tables) {
+      if (TableObj.isDbTable(table))
+        tableObjects[table.tableName] = table;
+      else {
+        const classTable = table;
+        tableObjects[classTable.name] = { columns: new classTable(), tableInfo: getTableInfo(classTable) };
       }
-      return this.getExpectedStructure(tableObjects);
-    } else {
-      const tableObjects = this.dbInstructions.tables;
-      return this.getExpectedStructure(tableObjects);
     }
-  }
-  getExpectedStructure(tableObjects) {
     const tables = {};
     for (const tableName in tableObjects) {
       const obj = tableObjects[tableName];
@@ -65,46 +108,49 @@ var TableStructureGenerator = class {
       tables[tableName] = {
         table: tableName,
         primaryKey: tableInfo?.primaryKey,
-        columns: this.getColumns(obj.columns, tableInfo?.primaryKey),
+        columns: this.getColumns(obj.columns, tableInfo),
         foreignKeys: tableInfo?.foreignKeys
       };
     }
     return tables;
   }
-  getColumns(obj, primaryKey) {
+  /**
+   * Retrieves the columns for a table
+   *
+   * @param obj - The table class interface object containing  properties that represent the table's fields.
+   * @param tableInfo - Optional metadata about the table. Can be undefined.
+   * @return An array of {@link ColumnInfo} representing the detailed column information.
+   */
+  getColumns(obj, tableInfo) {
     const columns = [];
     for (const property in obj) {
       const propertyKey = property;
       const value = obj[propertyKey];
       const columnData = {
         name: property,
-        isPrimaryKey: property == primaryKey,
-        type: "TEXT",
-        defaultValue: this.dialect.typeNull
+        isPrimaryKey: property == tableInfo?.primaryKey,
+        type: this.dialect.types.string,
+        defaultValue: this.dialect.types.null
       };
-      switch (typeof value) {
-        case "string":
-          columnData.type = this.dialect.typeString;
-          columnData.defaultValue = value === null ? this.dialect.typeNull : `"${this.dialect.formatValueToSql(value)}"`;
-          break;
-        case "bigint":
-          columnData.type = this.dialect.typeBigInt;
-          columnData.defaultValue = value === null ? this.dialect.typeNull : this.dialect.formatValueToSql(value);
-          break;
-        case "number":
-          columnData.type = this.dialect.typeInt;
-          columnData.defaultValue = value === null ? this.dialect.typeNull : this.dialect.formatValueToSql(value);
-          break;
-        case "boolean":
-          columnData.type = this.dialect.typeBoolean;
-          columnData.defaultValue = value === null ? this.dialect.typeNull : this.dialect.formatValueToSql(value);
-          break;
+      let dataType = tableInfo?.dataTypes?.[property] ?? typeof value;
+      switch (dataType) {
         case "function":
           continue;
-        default:
-          Logger.warn(`${obj.constructor.name}.${property} was skipped because its type is not supported (${typeof value})`);
+        case "object":
+          if (value instanceof Date) {
+            dataType = "date";
+            break;
+          } else {
+            Logger.warn(`${property} was skipped because its type (${typeof value}) is not supported`);
+            continue;
+          }
+        case "undefined":
+        case "symbol":
+          Logger.warn(`${property} was skipped because its type (${typeof value}) is not supported`);
           continue;
       }
+      columnData.defaultValue = value === null ? this.dialect.types.null : this.dialect.formatValueToSql(value, dataType);
+      columnData.type = this.dialect.types[dataType];
       columns.push(columnData);
     }
     return columns;
@@ -114,60 +160,129 @@ var TableStructureGenerator = class {
 // src/lib/exceptions/NotAllowedException.ts
 var NotAllowedException = class extends Error {
   constructor(entries) {
-    let message = "Some destructive changes need to be confirmed. In preMigrations() run:";
+    let message = "Some destructive changes need to be confirmed. In preMigration() run:\n";
     for (const entry of entries) {
-      message += `
-migrations.allowMigration(${entry.version}, "${entry.tableName}", "${entry.type}");`;
+      message += `		migrations.allowMigration(${entry.version}, ${entry.tableName}, "${entry.type}");
+`;
     }
-    super(`${message}
-
-`);
+    super(message);
   }
 };
 
-// src/lib/typings/Migrations.ts
+// src/lib/Migrations.ts
 var Migrations = class {
-  toVersion = 0;
-  alwaysAllowed = {};
   fromVersion = 0;
+  toVersion = 0;
+  lastUsedVersion = 0;
   migrationData = {};
+  migrationDataForOldTableNames = {};
+  alwaysAllowed = {};
   notAllowedChanges = [];
   reset(dbInstructions, fromVersion) {
     this.fromVersion = fromVersion;
-    this.migrationData = {};
     this.toVersion = dbInstructions.version;
+    this.migrationData = {};
+    this.migrationDataForOldTableNames = {};
     this.alwaysAllowed = dbInstructions.alwaysAllowedMigrations ?? {};
     this.notAllowedChanges = [];
   }
   getEntry(table) {
     const tableName = this.getTableName(table);
+    return this.getEntryFromTableName(tableName);
+  }
+  getEntryFromTableName(tableName) {
     if (!this.migrationData.hasOwnProperty(tableName)) {
       this.migrationData[tableName] = {
         recreate: false,
         renamedColumns: [],
-        allowedMigrations: {}
+        allowedMigrations: {},
+        usedMigrations: {}
       };
     }
     return this.migrationData[tableName];
   }
   getTableName(table) {
-    return typeof table == "string" ? table : table.name;
-  }
-  verifyMigration(tableName, type) {
-    if (!this.migrationData[tableName]?.allowedMigrations[type] && !this.alwaysAllowed[type])
-      this.notAllowedChanges.push({ version: this.toVersion, tableName, type });
-  }
-  checkIfAllowed(throwIfNotAllowed) {
-    if (!this.notAllowedChanges.length)
-      return true;
-    const exception = new NotAllowedException(this.notAllowedChanges);
-    if (throwIfNotAllowed)
-      throw exception;
-    else {
-      console.error(exception.message);
+    return TableObj.isDbTable(table) ? table.tableName : table.name;
+  }
+  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;
+  }
+  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 table "${migrationEntry.tableRenaming}" 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.find((column) => column.name == newColumnName))
+          return new Error(`You set column ${tableName}.${oldColumnName} to be renamed to ${tableName}.${newColumnName}. But ${tableName}.${newColumnName} does not exist in your structure.`);
+      }
+    }
+  }
+  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) {
+        if (!migration.usedMigrations[type])
+          errorMsg += `Migration "${type}" for ${tableName} was allowed but not needed.
+`;
+      }
+    }
+    if (errorMsg)
+      return new Error(errorMsg);
+  }
+  compareWithAllowedMigration(tableName, type) {
+    const migrationEntry = this.migrationData[tableName];
+    if (!migrationEntry?.allowedMigrations[type]) {
+      if (!this.alwaysAllowed[type])
+        this.notAllowedChanges.push({ version: this.toVersion, tableName, type });
+    } else if (migrationEntry)
+      migrationEntry.usedMigrations[type] = true;
+  }
+  getMigrationData() {
+    return this.migrationData;
+  }
+  loopRenamedColumns(tableName, callback) {
+    const migrationEntry = this.migrationData[tableName];
+    for (const renamingData of migrationEntry.renamedColumns) {
+      callback(renamingData.oldName, renamingData.newName);
     }
   }
+  getNewestTableName(tableName) {
+    return this.migrationDataForOldTableNames[tableName]?.tableRenaming?.newName ?? tableName;
+  }
+  getOldTableName(tableName) {
+    return this.migrationData[tableName]?.tableRenaming?.oldName ?? tableName;
+  }
+  getNewestColumnName(tableName, oldColumnName) {
+    const columnNames = this.migrationData[tableName]?.renamedColumns.find((columns) => columns.oldName == oldColumnName);
+    return columnNames ? columnNames.newName : oldColumnName;
+  }
+  willBeRecreated(tableName) {
+    return this.migrationData[tableName]?.recreate;
+  }
+  internalRecreate(tableName, reason) {
+    const entry = this.getEntryFromTableName(tableName);
+    entry.recreate = true;
+    Logger.log(`Table ${tableName} will be recreated(${reason})!`);
+  }
   allowMigration(version, table, ...allowedMigrations) {
     if (version < this.fromVersion || version > this.toVersion)
       return;
@@ -176,52 +291,33 @@ var Migrations = class {
       entry.allowedMigrations[key] = true;
     }
   }
-  renameTable(version, oldTableName, newTable) {
-    if (version < this.fromVersion || version > this.toVersion)
+  renameTable(version, oldTableName, newTableName) {
+    if (!this.versionIsRelevant(version))
       return;
-    const entry = this.getEntry(newTable);
-    entry.recreate = true;
-    if (!entry.oldTableName)
-      entry.oldTableName = oldTableName;
+    const newTableNameString = this.getTableName(newTableName);
+    const entry = this.getEntry(newTableName);
+    this.migrationDataForOldTableNames[oldTableName] = entry;
+    if (!entry.tableRenaming)
+      entry.tableRenaming = { oldName: oldTableName, newName: newTableNameString };
+    else
+      entry.tableRenaming.newName = newTableNameString;
   }
   renameColumn(version, table, oldColumn, newColumn) {
-    if (version < this.fromVersion || version > this.toVersion)
+    if (!this.versionIsRelevant(version))
       return;
     const entry = this.getEntry(table);
-    const existingColumnEntry = entry.renamedColumns.find((entry2) => entry2[entry2.length - 1] == oldColumn);
+    const existingColumnEntry = entry.renamedColumns.find((entry2) => entry2.newName == oldColumn);
     if (existingColumnEntry)
-      existingColumnEntry.push(newColumn);
+      existingColumnEntry.newName = newColumn;
     else
-      entry.renamedColumns.push([oldColumn, newColumn]);
-  }
-  recreateTableImp(table) {
-    const entry = this.getEntry(table);
-    entry.recreate = true;
+      entry.renamedColumns.push({ oldName: oldColumn, newName: newColumn });
   }
   recreateTable(version, table) {
-    if (version < this.fromVersion || version > this.toVersion)
+    if (!this.versionIsRelevant(version))
       return;
-    this.recreateTableImp(table);
-  }
-  getMigrationData() {
-    return this.migrationData;
-  }
-  loopRenamedColumns(tableName, callback) {
-    const migrationEntry = this.migrationData[tableName];
-    for (const renamingArray of migrationEntry.renamedColumns) {
-      if (renamingArray.length <= 1)
-        continue;
-      const oldColumnName = renamingArray[0];
-      const newColumnName = renamingArray[renamingArray.length - 1];
-      callback(oldColumnName, newColumnName);
-    }
-  }
-  getUpdatedColumnName(tableName, oldColumnName) {
-    const columnNames = this.migrationData[tableName]?.renamedColumns.find((columns) => columns[0] == oldColumnName);
-    return columnNames ? columnNames[columnNames.length - 1] : oldColumnName;
-  }
-  willBeRecreated(tableName) {
-    return this.migrationData[tableName]?.recreate;
+    const entry = this.getEntry(table);
+    entry.recreate = true;
+    Logger.log(`Table ${this.getTableName(table)} will be recreated!`);
   }
 };
 
@@ -229,6 +325,10 @@ var Migrations = class {
 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) {
@@ -286,8 +386,9 @@ ${preSQL.down}`;
       changes.down += initialChanges.down;
     } else {
       Logger.log(`Creating migration SQL from version ${fromVersion} to ${toVersion}`);
-      this.existingTables = await this.dialect.getTableNames();
+      this.existingTables = (await this.dialect.getTableNames()).map((oldTableName) => this.migrations.getNewestTableName(oldTableName));
       [
+        this.renameTables(),
         await this.createAndDropTables(),
         await this.migrateForeignKeys(),
         await this.migrateColumns(),
@@ -316,8 +417,18 @@ ${foreignKeyOnQuery}`;
     changes.down += `
 
 ${foreignKeyOnQuery}`;
-    if (!this.migrations.checkIfAllowed(dbInstructions.throwIfNotAllowed)) {
-      return null;
+    const exception = this.migrations.verifyRenamingTasks(this.newTables) ?? this.migrations.verifyAllowedMigrations();
+    if (exception) {
+      Logger.debug(`
+Canceled changes:
+${changes.up}
+`);
+      if (dbInstructions.throwIfNotAllowed)
+        throw exception;
+      else {
+        console.error(exception.message);
+        return null;
+      }
     }
     return {
       fromVersion,
@@ -325,6 +436,22 @@ ${foreignKeyOnQuery}`;
       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
@@ -336,8 +463,8 @@ ${foreignKeyOnQuery}`;
    */
   async createAndDropTables() {
     let changes = {
-      up: "\n\n-- Create tables\n",
-      down: "\n\n-- Create tables\n"
+      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)) {
@@ -350,12 +477,13 @@ ${foreignKeyOnQuery}`;
     }
     for (const tableName of this.existingTables) {
       if (!this.newTables[tableName]) {
-        this.migrations.verifyMigration(tableName, "dropTable");
+        this.migrations.compareWithAllowedMigration(tableName, "dropTable");
         if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
-          this.migrations.verifyMigration(tableName, "continueWithoutRollback");
+          this.migrations.compareWithAllowedMigration(tableName, "continueWithoutRollback");
+        const dbTableName = this.migrations.getOldTableName(tableName);
         changes.up += `${this.dialect.dropTable(tableName)}
 `;
-        changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(tableName, await this.dialect.getColumnInformation(tableName), await this.dialect.getForeignKeys(tableName)) : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
+        changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(tableName, await this.dialect.getColumnInformation(dbTableName), await this.dialect.getForeignKeys(dbTableName)) : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
       }
     }
     return changes;
@@ -406,10 +534,10 @@ ${foreignKeyOnQuery}`;
       const migrationEntry = migrationData[tableName];
       if (!migrationEntry.recreate)
         continue;
-      this.migrations.verifyMigration(tableName, "recreateTable");
+      this.migrations.compareWithAllowedMigration(tableName, "recreateTable");
       if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
-        this.migrations.verifyMigration(tableName, "continueWithoutRollback");
-      const oldColumnList = await this.dialect.getColumnInformation(tableName);
+        this.migrations.compareWithAllowedMigration(tableName, "continueWithoutRollback");
+      const oldColumnList = await this.dialect.getColumnInformation(this.migrations.getOldTableName(tableName));
       const newColumnList = this.newTables[tableName].columns;
       const moveableColumns = newColumnList.filter((entry) => oldColumnList.find((oldEntry) => oldEntry.name == entry.name) != void 0).map((entry) => entry.name);
       const backupTableName = `${tableName}__backup`;
@@ -419,8 +547,9 @@ ${foreignKeyOnQuery}`;
       );
       const moveDataQuery = insertQuery + "\n" + this.dialect.dropTable(tableName) + "\n" + this.dialect.renameTable(backupTableName, tableName);
       const structure = this.newTables[tableName];
-      changes.up += this.createTableSql(backupTableName, structure.columns, structure.foreignKeys) + "\n" + moveDataQuery;
-      changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(backupTableName, await this.dialect.getColumnInformation(tableName), await this.dialect.getForeignKeys(tableName)) + "\n" + moveDataQuery : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
+      changes.up += this.createTableSql(backupTableName, structure.columns, structure.foreignKeys) + "\n" + moveDataQuery + "\n";
+      const dbTableName = this.migrations.getOldTableName(tableName);
+      changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(backupTableName, await this.dialect.getColumnInformation(dbTableName), await this.dialect.getForeignKeys(dbTableName)) + "\n" + moveDataQuery : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
     }
     return changes;
   }
@@ -428,8 +557,6 @@ ${foreignKeyOnQuery}`;
    * Migrates foreign key constraints for all defined tables.
    */
   async migrateForeignKeys() {
-    if (!this.dialect.canAlterForeignKeys)
-      return { up: "", down: "" };
     let changes = {
       up: "\n\n-- Foreign keys\n",
       down: "\n\n-- Foreign keys\n"
@@ -439,13 +566,13 @@ ${foreignKeyOnQuery}`;
         continue;
       const structure = this.newTables[tableName];
       const newForeignKeys = structure.foreignKeys ?? [];
-      const oldForeignKeys = await this.dialect.getForeignKeys(tableName);
+      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.toTable}.${oldForeignKey.toColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} was removed!`);
-          this.migrations.verifyMigration(tableName, "removeForeignKey");
+          Logger.log(`Foreign key ${oldForeignKey.fromTable}.${oldForeignKey.fromColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} will be removed!`);
+          this.migrations.compareWithAllowedMigration(tableName, "removeForeignKey");
           if (this.dialect.canAlterForeignKeys) {
             changes.up += this.dialect.removeForeignKey(oldForeignKey.fromTable, oldForeignKey.fromColumn);
             changes.down += this.dialect.addForeignKey(
@@ -453,13 +580,13 @@ ${foreignKeyOnQuery}`;
               this.dialect.foreignKey(oldForeignKey.fromColumn, oldForeignKey.toTable, oldForeignKey.toColumn, oldForeignKey.onUpdate, oldForeignKey.onDelete)
             );
           } else {
-            this.migrations.recreateTableImp(structure.table);
+            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.toTable}.${oldForeignKey.toColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} was changed!`);
-            this.migrations.verifyMigration(tableName, "alterForeignKey");
+            Logger.log(`Foreign key ${oldForeignKey.fromTable}.${oldForeignKey.fromColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} will be changed!`);
+            this.migrations.compareWithAllowedMigration(tableName, "alterForeignKey");
             if (this.dialect.canAlterForeignKeys) {
               changes.up += this.dialect.removeForeignKey(oldForeignKey.fromTable, oldForeignKey.fromColumn) + this.dialect.addForeignKey(
                 newForeignKey.fromTable,
@@ -470,7 +597,7 @@ ${foreignKeyOnQuery}`;
                 this.dialect.foreignKey(oldForeignKey.fromColumn, oldForeignKey.toTable, oldForeignKey.toColumn, oldForeignKey.onUpdate, oldForeignKey.onDelete)
               ) + this.dialect.removeForeignKey(newForeignKey.fromTable, newForeignKey.fromColumn);
             } else {
-              this.migrations.recreateTableImp(structure.table);
+              this.migrations.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
               checkForNewForeignKeys = false;
             }
           }
@@ -481,7 +608,7 @@ ${foreignKeyOnQuery}`;
           const oldForeignKey = oldForeignKeys.find((entry) => entry.fromColumn == newForeignKey.fromColumn);
           if (oldForeignKey)
             continue;
-          Logger.log(`Foreign key ${newForeignKey.toTable}.${newForeignKey.toColumn} to ${newForeignKey.toTable}.${newForeignKey.toColumn} is new!`);
+          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,
@@ -489,7 +616,7 @@ ${foreignKeyOnQuery}`;
             );
             changes.down += this.dialect.removeForeignKey(newForeignKey.fromTable, newForeignKey.fromColumn);
           } else {
-            this.migrations.recreateTableImp(structure.table);
+            this.migrations.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
             break;
           }
         }
@@ -510,13 +637,13 @@ ${foreignKeyOnQuery}`;
       if (this.migrations.willBeRecreated(tableName) || this.tableDoesNotExists(tableName))
         continue;
       const newTableDefinition = this.newTables[tableName];
-      const oldColumnList = await this.dialect.getColumnInformation(tableName);
+      const oldColumnList = await this.dialect.getColumnInformation(this.migrations.getOldTableName(tableName));
       const oldPrimaryKey = this.dialect.canInspectPrimaryKey ? this.getPrimaryKeyColumn(oldColumnList) : false;
       const newColumnList = newTableDefinition.columns;
       const newPrimaryKey = newTableDefinition.primaryKey;
       if (this.dialect.canInspectPrimaryKey && oldPrimaryKey != newPrimaryKey) {
-        Logger.log(`Primary key in ${tableName} was changed from ${oldPrimaryKey} to ${newPrimaryKey}!`);
-        this.migrations.verifyMigration(tableName, "alterPrimaryKey");
+        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);
@@ -527,26 +654,26 @@ ${foreignKeyOnQuery}`;
             changes.down += this.dialect.removePrimaryKey(tableName, newPrimaryKey.toString());
           }
         } else
-          this.migrations.recreateTableImp(newTableDefinition.table);
+          this.migrations.internalRecreate(newTableDefinition.table, "Dialect does not support altering primary keys");
         continue;
       }
       for (const newColumn of newColumnList) {
         const oldColumn = oldColumnList.find(
-          (entry) => this.migrations.getUpdatedColumnName(tableName, entry.name) == newColumn.name
+          (entry) => this.migrations.getNewestColumnName(tableName, entry.name) == newColumn.name
         );
         if (oldColumn == void 0) {
           changes.up += this.dialect.createColumn(tableName, this.dialect.columnDefinition(newColumn.name, newColumn.type, newColumn.defaultValue, newColumn.isPrimaryKey)) + "\n";
           changes.down += this.dialect.dropColumn(tableName, newColumn.name) + "\n";
         } else if (newColumn.type != oldColumn.type || newColumn.defaultValue != oldColumn.defaultValue) {
-          this.migrations.recreateTableImp(newTableDefinition.table);
+          this.migrations.internalRecreate(newTableDefinition.table, "Table structure was changed");
         }
       }
       for (const oldColumn of oldColumnList) {
         const newColumn = newColumnList.find(
-          (entry) => entry.name == this.migrations.getUpdatedColumnName(tableName, oldColumn.name)
+          (entry) => entry.name == this.migrations.getNewestColumnName(tableName, oldColumn.name)
         );
         if (newColumn == void 0) {
-          this.migrations.verifyMigration(tableName, "dropColumn");
+          this.migrations.compareWithAllowedMigration(tableName, "dropColumn");
           changes.up += this.dialect.dropColumn(tableName, oldColumn.name) + "\n";
           changes.down += this.dialect.createColumn(tableName, this.dialect.columnDefinition(oldColumn.name, oldColumn.type, oldColumn.defaultValue, oldColumn.isPrimaryKey)) + "\n";
         }
@@ -580,6 +707,7 @@ ${foreignKeyOnQuery}`;
       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);
       });
@@ -646,24 +774,37 @@ ${changes.down}`, { encoding: "utf-8" });
   }
 };
 
-// src/lib/tableInfo/decorators/DbTable.ts
+// src/lib/tableInfo/decorators/TableClass.ts
 import "polyfill-symbol-metadata";
-function DbTable(tableName, primaryKey) {
+function TableClass(tableName, primaryKey) {
   return (table, context) => {
-    Object.defineProperty(table, "name", { value: tableName, writable: false });
     const tableInfo = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
     tableInfo.primaryKey = primaryKey?.toString();
     if (tableInfo.foreignKeys) {
       for (const foreignKey of tableInfo.foreignKeys) {
         foreignKey.fromTable = tableName;
+        if (foreignKey.toTable == table.name)
+          foreignKey.toTable = tableName;
       }
     }
+    Object.defineProperty(table, "name", { value: tableName, writable: false });
+  };
+}
+
+// src/lib/tableInfo/decorators/DataType.ts
+import "polyfill-symbol-metadata";
+function DataType(type) {
+  return (table, context) => {
+    const metadata = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
+    if (!metadata.dataTypes)
+      metadata.dataTypes = {};
+    metadata.dataTypes[context.name ?? context] = type;
   };
 }
 
 // src/lib/tableInfo/decorators/ForeignKey.ts
 import "polyfill-symbol-metadata";
-function ForeignKey(toTable, toColumn, onDelete, onUpdate) {
+function ForeignKey(toTable, toColumn, options) {
   return (table, context) => {
     const metadata = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
     if (!metadata.foreignKeys)
@@ -674,8 +815,8 @@ function ForeignKey(toTable, toColumn, onDelete, onUpdate) {
       //to stay compatible with old decorator structure (see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#decorator-metadata)
       toTable: toTable.name,
       toColumn: toColumn.toString(),
-      onDelete,
-      onUpdate
+      onDelete: options?.onDelete,
+      onUpdate: options?.onUpdate
     });
   };
 }
@@ -688,32 +829,108 @@ var DefaultSql = class {
   canAlterPrimaryKey = false;
   canInspectForeignKeys = false;
   canInspectPrimaryKey = false;
-  typeString = "TEXT";
-  typeInt = "INTEGER";
-  typeBigInt = "BIGINT";
-  typeBoolean = "BOOLEAN";
-  typeNull = "NULL";
+  types = {
+    string: "TEXT",
+    number: "INTEGER",
+    bigint: "BIGINT",
+    boolean: "BOOLEAN",
+    date: "DATE",
+    time: "TIME",
+    dateTime: "DATETIME",
+    null: "NULL"
+  };
   constructor(db) {
     this.db = db;
   }
-  formatValueToSql(value) {
-    return value.toString();
+  /**
+   * 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 TableInfo} setting
+   * @return A string representation of the value formatted for SQL.
+   */
+  formatValueToSql(value, type) {
+    function toDate(value2) {
+      return value2 instanceof Date ? value2 : new Date(value2);
+    }
+    switch (type) {
+      case "string":
+        return `"${value}"`;
+      case "time":
+        return toDate(value).toISOString().slice(11, 19);
+      case "date":
+        return toDate(value).toISOString().slice(0, 10);
+      case "dateTime":
+        return toDate(value).toISOString().slice(0, 19).replace("T", " ");
+      default:
+        return value.toString();
+    }
   }
+  /**
+   * Query to enable / disable foreign keys in the database.
+   * Is dialect specific.
+   *
+   * @param enabled - A boolean indicating whether to enable or disable foreign key constraints.
+   * @return The query
+   */
   changeForeignKeysState(enabled) {
     return "";
   }
+  /**
+   * Query 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 that adds the foreign key to the specified table.
+   */
   addForeignKey(fromTableName, foreignKey) {
     throw new Error("Adding foreign keys is not supported!");
   }
+  /**
+   * Query 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 that removes the foreign key from the specified table.
+   */
   removeForeignKey(tableName, foreignKeyName) {
     throw new Error("Foreign key removal is not supported!");
   }
+  /**
+   * Query 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 A SQL statement to add a primary key to the specified table and column.
+   */
   addPrimaryKey(tableName, columnName) {
     throw new Error("Adding foreign keys is not supported!");
   }
+  /**
+   * Query 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 A SQL statement to remove a primary key from the specified table and column.
+   */
   removePrimaryKey(tableName, columnName) {
     throw new Error("Foreign key removal is not supported!");
   }
+  /**
+   * Constructs a SQL FOREIGN KEY constraint clause.
+   * Used in combination with {@link addForeignKey} or {@link createTable}
+   *
+   * @param column - The name of the column in the current table to apply the foreign key constraint.
+   * @param foreignTable - The name of the referenced table.
+   * @param foreignColumn - The name of the referenced column in the foreign table.
+   * @param onUpdate - Optional action to specify the behavior on update (e.g., CASCADE, SET NULL).
+   * @param onDelete - Optional action to specify the behavior on delete (e.g., CASCADE, SET NULL).
+   * @return The SQL string representing the foreign key constraint.
+   */
   foreignKey(column, foreignTable, foreignColumn, onUpdate, onDelete) {
     let query = `FOREIGN KEY (${column}) REFERENCES ${foreignTable} (${foreignColumn})`;
     if (onUpdate)
@@ -763,7 +980,7 @@ var DefaultSql = class {
   }
   migrationTableQuery() {
     return this.createTable(MIGRATION_DATA_TABLE_NAME, [
-      this.columnDefinition("version", this.typeInt, "0", false)
+      this.columnDefinition("version", this.types.number, "0", false)
     ]);
   }
   async getForeignKeys(tableName) {
@@ -792,8 +1009,16 @@ UPDATE ${MIGRATION_DATA_TABLE_NAME} SET version = ${newVersion} WHERE EXISTS (SE
 
 // src/lib/dialects/SqliteDialect.ts
 var SqliteDialect = class extends DefaultSql {
-  typeBoolean = "INTEGER";
-  typeBigInt = "INTEGER";
+  types = {
+    string: "TEXT",
+    number: "INTEGER",
+    bigint: "INTEGER",
+    boolean: "INTEGER",
+    date: "DATE",
+    time: "TIME",
+    dateTime: "DATETIME",
+    null: "NULL"
+  };
   canAlterForeignKeys = false;
   canAlterPrimaryKey = false;
   canInspectForeignKeys = true;
@@ -815,12 +1040,19 @@ var SqliteDialect = class extends DefaultSql {
       };
     });
   }
-  formatValueToSql(value) {
-    switch (typeof value) {
+  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 value.toString();
+        return super.formatValueToSql(value, type);
     }
   }
   async getForeignKeys(tableName) {
@@ -1057,8 +1289,10 @@ async function rollback(db, dbInstructions, toVersion) {
   await dialect.setVersion(toVersion);
 }
 export {
-  DbTable,
+  DataType,
   ForeignKey,
+  TableClass,
+  TableObj,
   prepareAndRunMigration,
   prepareMigration,
   rollback,