sqlmorpheus 0.2.0 → 0.2.2

package/dist/index.mjs

@@ -21,19 +21,110 @@ var LoggerClass = class {
 };
 var Logger = new LoggerClass();
 
-// src/lib/tableInfo/TableInfo.ts
+// src/lib/tableInfo/TableObj.ts
+var TableObj = class _TableObj {
+  IS_TABLE_OBJ = true;
+  tableName;
+  tableStructure = {
+    table: "",
+    primaryKey: void 0,
+    columns: {},
+    foreignKeys: []
+  };
+  static getEmptyColumnEntry(key) {
+    return {
+      name: key,
+      type: "",
+      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 {
+          Logger.warn(`${key} was skipped because its type (${typeof value}) is not supported`);
+          return null;
+        }
+      case "undefined":
+      case "symbol":
+        Logger.warn(`${key} was skipped because its type (${typeof value}) is not supported`);
+        return null;
+    }
+    return {
+      ..._TableObj.getEmptyColumnEntry(key),
+      inputType: dataType,
+      inputDefaultValue: value
+    };
+  }
+  constructor(tableName, defaultValues) {
+    this.tableName = tableName;
+    for (const key in defaultValues) {
+      const value = defaultValues[key];
+      const columnEntry = _TableObj.getColumnEntry(key, value);
+      if (!columnEntry)
+        continue;
+      this.tableStructure.columns[key] = columnEntry;
+    }
+  }
+  primaryKey(key) {
+    this.tableStructure.primaryKey = key.toString();
+    this.tableStructure.columns[key.toString()].isPrimaryKey = true;
+    return this;
+  }
+  foreignKey(fromColumn, toTable, toColumn, options) {
+    this.tableStructure.foreignKeys.push({
+      fromTable: this.tableName,
+      fromColumn: fromColumn.toString(),
+      toTable: toTable.tableName,
+      toColumn: toColumn.toString(),
+      onUpdate: options?.onUpdate,
+      onDelete: options?.onDelete
+    });
+    return this;
+  }
+  dataType(column, type) {
+    this.tableStructure.columns[column.toString()].type = type;
+    return this;
+  }
+  maxCharacterLength(column, max) {
+    this.tableStructure.columns[column.toString()].maxLength = max;
+    return this;
+  }
+  static create(tableName, columns) {
+    return new _TableObj(tableName, columns);
+  }
+  static isTableObj(obj) {
+    return !!obj?.IS_TABLE_OBJ;
+  }
+};
+
+// src/lib/tableInfo/getTableStructure.ts
 var TABLE_INFO_PROPERTY_NAME = Symbol("tableInfo");
-function getTableInfo(table) {
+function getInputColumnInfo(table, context) {
+  const metadata = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(table);
+  const key = context.name ?? context;
+  if (!metadata.columns.hasOwnProperty(key))
+    metadata.columns[key] = TableObj.getEmptyColumnEntry(key);
+  return metadata.columns[key];
+}
+function getTableStructure(table) {
   let metadata = table[Symbol.metadata] ?? table.prototype?.[Symbol.metadata];
   if (!metadata) {
     metadata = {};
     table[Symbol.metadata] = metadata;
   }
-  return getTableInfoFromMetadata(metadata);
+  return getTableStructureFromMetadata(metadata);
 }
-function getTableInfoFromMetadata(metadata) {
+function getTableStructureFromMetadata(metadata) {
   if (!metadata[TABLE_INFO_PROPERTY_NAME])
-    metadata[TABLE_INFO_PROPERTY_NAME] = { primaryKey: "", foreignKeys: [] };
+    metadata[TABLE_INFO_PROPERTY_NAME] = { table: "", primaryKey: "", foreignKeys: [], columns: {} };
   return metadata[TABLE_INFO_PROPERTY_NAME];
 }
 
@@ -45,101 +136,85 @@ 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) };
-      }
-      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];
-      const tableInfo = obj.tableInfo;
-      tables[tableName] = {
-        table: tableName,
-        primaryKey: tableInfo?.primaryKey,
-        columns: this.getColumns(obj.columns, tableInfo?.primaryKey),
-        foreignKeys: tableInfo?.foreignKeys
-      };
-    }
-    return tables;
-  }
-  getColumns(obj, primaryKey) {
-    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
-      };
-      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;
-        case "function":
-          continue;
-        default:
-          Logger.warn(`${obj.constructor.name}.${property} was skipped because its type is not supported (${typeof value})`);
-          continue;
+    for (const table of this.dbInstructions.tables) {
+      if (TableObj.isTableObj(table)) {
+        tables[table.tableName] = table.tableStructure;
+      } else {
+        const classTable = table;
+        const structure = getTableStructure(classTable);
+        tables[classTable.name] = structure;
+        for (const key in structure.columns) {
+          const entry = structure.columns[key];
+          entry.defaultValue = entry.defaultValue === null ? this.dialect.types.null : this.dialect.formatValueToSql(entry.inputDefaultValue, entry.inputType);
+          entry.type = this.dialect.getSqlType(entry.inputType, entry);
+        }
       }
-      columns.push(columnData);
     }
-    return columns;
+    return tables;
   }
 };
 
 // src/lib/exceptions/NotAllowedException.ts
 var NotAllowedException = class extends Error {
   constructor(entries) {
-    let message = "Some destructive changes need to be confirmed.\n	In preMigration() run:\n";
+    let message = "Some destructive changes need to be confirmed. To confirm, add to preMigration():\n";
     for (const entry of entries) {
-      message += `		migrations.allowMigration(${entry.version}, "${entry.tableName}", "${entry.type}");
+      message += `		migrations.allowMigration(${entry.version}, ${entry.tableName}, "${entry.type}");
 `;
     }
     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 = [];
+  /**
+   * 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.migrationData = {};
     this.toVersion = dbInstructions.version;
+    this.migrationData = {};
+    this.migrationDataForOldTableNames = {};
     this.alwaysAllowed = dbInstructions.alwaysAllowedMigrations ?? {};
     this.notAllowedChanges = [];
   }
+  /**
+   * Retrieves the migration instructions for the specified table.
+   * @see getEntryFromTableName
+   *
+   * @param table - The {@link TableInput} object from which the table name will be retrieved.
+   * @return The migration instructions corresponding to the given table input.
+   */
   getEntry(table) {
     const tableName = this.getTableName(table);
+    return this.getEntryFromTableName(tableName);
+  }
+  /**
+   * Retrieves the migration instructions for the specified table.
+   *
+   * @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,
@@ -150,28 +225,67 @@ var Migrations = class {
     }
     return this.migrationData[tableName];
   }
+  /**
+   * Retrieves the table name from the given table input.
+   *
+   * @param table - The {@link TableInput} object.
+   * @return The name of the table derived from either {@link TableObj} or a class.
+   */
   getTableName(table) {
-    return typeof table == "string" ? table : table.name;
+    return TableObj.isTableObj(table) ? table.tableName : table.name;
+  }
+  /**
+   * Checks whether a provided version is relevant based on database version ({@link fromVersion}) and target version ({@link toVersion}).
+   * Also makes sure that version checks happen in order.
+   *
+   * @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?.oldName == tableName)
-        return new Error(`You set table "${tableName}" to be renamed to itself!`);
-      if (migrationEntry.tableRenaming && 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.`);
+      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))
+        else if (!newTables[tableName]?.columns[newColumnName])
           return new Error(`You set column ${tableName}.${oldColumnName} to be renamed to ${tableName}.${newColumnName}. But ${tableName}.${newColumnName} does not exist in your structure.`);
       }
     }
   }
+  /**
+   * Making sure all considered calls to {@link allowMigration()} where necessary to prevent input mistakes.
+   * Called after all SQL queries have been generated.
+   * Only used internally.
+   *
+   * @throws Error if unnecessary calls were discovered. All discovered calls are collected and thrown as one Error.
+   */
   verifyAllowedMigrations() {
     if (this.notAllowedChanges.length)
       return new NotAllowedException(this.notAllowedChanges);
@@ -187,6 +301,14 @@ var Migrations = class {
     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.
+   */
   compareWithAllowedMigration(tableName, type) {
     const migrationEntry = this.migrationData[tableName];
     if (!migrationEntry?.allowedMigrations[type]) {
@@ -195,22 +317,118 @@ var Migrations = class {
     } else if (migrationEntry)
       migrationEntry.usedMigrations[type] = true;
   }
+  /**
+   * 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 table - Either a {@link TableObj} or a class decorated with @TableClass.
+   * @param allowedMigrations - The keys representing the migrations to be allowed. Multiple migrations can be provided
+   */
   allowMigration(version, table, ...allowedMigrations) {
-    if (version < this.fromVersion || version > this.toVersion)
+    if (!this.versionIsRelevant(version))
       return;
     const entry = this.getEntry(table);
     for (const key of allowedMigrations) {
       entry.allowedMigrations[key] = true;
     }
   }
+  /**
+   * 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.
+   * @param newTableName - The new table name or its equivalent input format.
+   */
   renameTable(version, oldTableName, newTableName) {
-    if (version < this.fromVersion || version > this.toVersion)
+    if (!this.versionIsRelevant(version))
       return;
     const newTableNameString = this.getTableName(newTableName);
-    if (this.migrationData.hasOwnProperty(oldTableName)) {
-      this.migrationData[newTableNameString] = this.getEntry(oldTableName);
-      delete this.migrationData[oldTableName];
-    }
     const entry = this.getEntry(newTableName);
     this.migrationDataForOldTableNames[oldTableName] = entry;
     if (!entry.tableRenaming)
@@ -218,8 +436,19 @@ var Migrations = class {
     else
       entry.tableRenaming.newName = newTableNameString;
   }
+  /**
+   * 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 table Either a {@link TableObj} or a class decorated with @TableClass containing the column to be renamed.
+   * @param oldColumn The current name in the database at the time of the migration.
+   * @param newColumn The new name to assign to the column.
+   */
   renameColumn(version, table, oldColumn, newColumn) {
-    if (version < this.fromVersion || version > this.toVersion)
+    if (!this.versionIsRelevant(version))
       return;
     const entry = this.getEntry(table);
     const existingColumnEntry = entry.renamedColumns.find((entry2) => entry2.newName == oldColumn);
@@ -228,36 +457,21 @@ var Migrations = class {
     else
       entry.renamedColumns.push({ oldName: oldColumn, newName: newColumn });
   }
-  recreateTableImp(table) {
-    const entry = this.getEntry(table);
-    entry.recreate = true;
-  }
+  /**
+   * 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 table Either a {@link TableObj} or a class decorated with @TableClass.
+   */
   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 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;
+    const entry = this.getEntry(table);
+    entry.recreate = true;
+    Logger.log(`Table ${this.getTableName(table)} will be recreated!`);
   }
 };
 
@@ -440,8 +654,9 @@ ${changes.up}
    */
   createTableSql(tableName, columns, foreignKeys) {
     const queryLines = [];
-    for (const columnInfo of columns) {
-      queryLines.push(this.dialect.columnDefinition(columnInfo.name, columnInfo.type, columnInfo.defaultValue, columnInfo.isPrimaryKey));
+    for (const key in columns) {
+      const columnInfo = columns[key];
+      queryLines.push(this.dialect.columnDefinition(columnInfo.name, columnInfo.type, columnInfo.isPrimaryKey, columnInfo.defaultValue));
     }
     if (foreignKeys) {
       for (const foreignKeyInfo of foreignKeys) {
@@ -474,13 +689,16 @@ ${changes.up}
       const migrationEntry = migrationData[tableName];
       if (!migrationEntry.recreate)
         continue;
-      Logger.log(`Table ${tableName} will be recreated!`);
       this.migrations.compareWithAllowedMigration(tableName, "recreateTable");
       if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
         this.migrations.compareWithAllowedMigration(tableName, "continueWithoutRollback");
       const oldColumnList = await this.dialect.getColumnInformation(this.migrations.getOldTableName(tableName));
       const newColumnList = this.newTables[tableName].columns;
-      const moveableColumns = newColumnList.filter((entry) => oldColumnList.find((oldEntry) => oldEntry.name == entry.name) != void 0).map((entry) => entry.name);
+      const moveableColumns = [];
+      for (const key in newColumnList) {
+        if (oldColumnList.hasOwnProperty(key))
+          moveableColumns.push(newColumnList[key].name);
+      }
       const backupTableName = `${tableName}__backup`;
       const insertQuery = this.dialect.insert(
         backupTableName,
@@ -488,7 +706,7 @@ ${changes.up}
       );
       const moveDataQuery = insertQuery + "\n" + this.dialect.dropTable(tableName) + "\n" + this.dialect.renameTable(backupTableName, tableName);
       const structure = this.newTables[tableName];
-      changes.up += this.createTableSql(backupTableName, structure.columns, structure.foreignKeys) + "\n" + moveDataQuery + "\n";
+      changes.up += this.createTableSql(backupTableName, structure.columns, structure.foreignKeys) + "\n" + moveDataQuery + "\n\n";
       const dbTableName = this.migrations.getOldTableName(tableName);
       changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(backupTableName, await this.dialect.getColumnInformation(dbTableName), await this.dialect.getForeignKeys(dbTableName)) + "\n" + moveDataQuery : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
     }
@@ -521,7 +739,7 @@ ${changes.up}
               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 {
@@ -538,7 +756,7 @@ ${changes.up}
                 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;
             }
           }
@@ -557,7 +775,7 @@ ${changes.up}
             );
             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;
           }
         }
@@ -580,6 +798,10 @@ ${changes.up}
       const newTableDefinition = this.newTables[tableName];
       const oldColumnList = await this.dialect.getColumnInformation(this.migrations.getOldTableName(tableName));
       const oldPrimaryKey = this.dialect.canInspectPrimaryKey ? this.getPrimaryKeyColumn(oldColumnList) : false;
+      const oldColumnNewNameIndex = {};
+      for (const key in oldColumnList) {
+        oldColumnNewNameIndex[this.migrations.getNewestColumnName(tableName, key)] = oldColumnList[key];
+      }
       const newColumnList = newTableDefinition.columns;
       const newPrimaryKey = newTableDefinition.primaryKey;
       if (this.dialect.canInspectPrimaryKey && oldPrimaryKey != newPrimaryKey) {
@@ -595,28 +817,26 @@ ${changes.up}
             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.getNewestColumnName(tableName, entry.name) == newColumn.name
-        );
+      for (const key in newColumnList) {
+        const newColumn = newColumnList[key];
+        const oldColumn = oldColumnNewNameIndex[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.up += this.dialect.createColumn(tableName, this.dialect.columnDefinition(newColumn.name, newColumn.type, newColumn.isPrimaryKey, newColumn.defaultValue)) + "\n";
           changes.down += this.dialect.dropColumn(tableName, newColumn.name) + "\n";
         } else if (newColumn.type != oldColumn.type || newColumn.defaultValue != oldColumn.defaultValue) {
-          this.migrations.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.getNewestColumnName(tableName, oldColumn.name)
-        );
+      for (const key in oldColumnList) {
+        const oldColumn = oldColumnList[key];
+        const newColumn = newColumnList[this.migrations.getNewestColumnName(tableName, oldColumn.name)];
         if (newColumn == void 0) {
           this.migrations.compareWithAllowedMigration(tableName, "dropColumn");
           changes.up += this.dialect.dropColumn(tableName, oldColumn.name) + "\n";
-          changes.down += this.dialect.createColumn(tableName, this.dialect.columnDefinition(oldColumn.name, oldColumn.type, oldColumn.defaultValue, oldColumn.isPrimaryKey)) + "\n";
+          changes.down += this.dialect.createColumn(tableName, this.dialect.columnDefinition(oldColumn.name, oldColumn.type, oldColumn.isPrimaryKey, oldColumn.defaultValue)) + "\n";
         }
       }
     }
@@ -625,11 +845,12 @@ ${changes.up}
   /**
    * Retrieves the name of the primary key column from a list of column information.
    *
-   * @param columnInfoList - An array of ColumnInfo objects containing details about each column.
+   * @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(columnInfoList) {
-    for (const columnInfo of columnInfoList) {
+  getPrimaryKeyColumn(columnInfoEntries) {
+    for (const key in columnInfoEntries) {
+      const columnInfo = columnInfoEntries[key];
       if (columnInfo.isPrimaryKey)
         return columnInfo.name;
     }
@@ -715,26 +936,49 @@ ${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) {
+    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;
       }
     }
+    for (const key in table) {
+      const value = table[key];
+      const existingEntry = tableStructure.columns[key];
+      const defaultEntry = TableObj.getColumnEntry(key, value);
+      if (!defaultEntry)
+        continue;
+      tableStructure.columns[key] = {
+        ...defaultEntry,
+        ...existingEntry
+      };
+    }
+    Object.defineProperty(table, "name", { value: tableName, writable: false });
+  };
+}
+
+// src/lib/tableInfo/decorators/DataType.ts
+import "polyfill-symbol-metadata";
+function DataType(type) {
+  return (table, context) => {
+    const entry = getInputColumnInfo(table, context);
+    entry.inputType = type;
   };
 }
 
 // src/lib/tableInfo/decorators/ForeignKey.ts
 import "polyfill-symbol-metadata";
-function ForeignKey(toTable, toColumn, onDelete, onUpdate) {
+function ForeignKey(toTable, toColumn, options) {
   return (table, context) => {
-    const metadata = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
+    const metadata = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(table);
     if (!metadata.foreignKeys)
       metadata.foreignKeys = [];
     metadata.foreignKeys.push({
@@ -743,8 +987,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
     });
   };
 }
@@ -757,32 +1001,111 @@ 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 TableStructure} setting
+   * @return A string representation of the value formatted for SQL.
+   */
+  formatValueToSql(value, type) {
+    function toDate(value2) {
+      return value2 instanceof Date ? value2 : new Date(value2);
+    }
+    switch (type) {
+      case "string":
+        return `"${value}"`;
+      case "time":
+        return `"${toDate(value).toISOString().slice(11, 19)}"`;
+      case "date":
+        return `"${toDate(value).toISOString().slice(0, 10)}"`;
+      case "dateTime":
+        return `"${toDate(value).toISOString().slice(0, 19).replace("T", " ")}"`;
+      default:
+        return value.toString();
+    }
+  }
+  getSqlType(dataType, _) {
+    return this.types[dataType];
   }
+  /**
+   * Statement to enable / disable foreign keys in the database.
+   * Is dialect specific.
+   *
+   * @param enabled - A boolean indicating whether to enable or disable foreign key constraints.
+   * @return The SQL statement as a string.
+   */
   changeForeignKeysState(enabled) {
     return "";
   }
+  /**
+   * Statement to add a foreign key to a specified table.
+   * Is only used if {@link canAlterForeignKeys} is true.
+   *
+   * @param fromTableName - The name of the table to which the foreign key will be added.
+   * @param foreignKey - The foreign key definition to be added, see {@link foreignKey()}.
+   * @return The SQL statement as a string.
+   */
   addForeignKey(fromTableName, foreignKey) {
     throw new Error("Adding foreign keys is not supported!");
   }
+  /**
+   * Statement to remove a foreign key from a specified table.
+   * Is only used if {@link canAlterForeignKeys} is true.
+   *
+   * @param tableName - The name of the table to which the foreign key will be added.
+   * @param foreignKeyName - The name of the foreign key definition.
+   * @return The SQL statement as a string.
+   */
   removeForeignKey(tableName, foreignKeyName) {
     throw new Error("Foreign key removal is not supported!");
   }
+  /**
+   * Statement to add a primary key to the specified table.
+   * Is only used if {@link canAlterPrimaryKey} is true.
+   *
+   * @param tableName - The name of the table to which the primary key will be added.
+   * @param columnName - The name of the column that will be set as the primary key.
+   * @return The SQL statement as a string.
+   */
   addPrimaryKey(tableName, columnName) {
     throw new Error("Adding foreign keys is not supported!");
   }
+  /**
+   * Statement to remove a primary key from the specified table.
+   * Is only used if {@link canAlterPrimaryKey} is true.
+   *
+   * @param tableName - The name of the table to which the primary key will be added.
+   * @param columnName - The name of the column that will be set as the primary key.
+   * @return The SQL statement as a string.
+   */
   removePrimaryKey(tableName, columnName) {
     throw new Error("Foreign key removal is not supported!");
   }
+  /**
+   * Constructs a SQL FOREIGN KEY constraint clause.
+   * Used in combination with {@link addForeignKey} or {@link createTable}
+   *
+   * @param column - The name of the column in the current table to apply the foreign key constraint.
+   * @param foreignTable - The name of the referenced table.
+   * @param foreignColumn - The name of the referenced column in the foreign table.
+   * @param onUpdate - Optional action to specify the behavior on update (e.g., CASCADE, SET NULL).
+   * @param onDelete - Optional action to specify the behavior on delete (e.g., CASCADE, SET NULL).
+   * @return The SQL string representing the foreign key constraint.
+   */
   foreignKey(column, foreignTable, foreignColumn, onUpdate, onDelete) {
     let query = `FOREIGN KEY (${column}) REFERENCES ${foreignTable} (${foreignColumn})`;
     if (onUpdate)
@@ -791,64 +1114,164 @@ var DefaultSql = class {
       query += ` ON DELETE ${onDelete}`;
     return query;
   }
+  /**
+   * Statement to create a table if it does not already exist.
+   *
+   * @param tableName - The name of the table to be created.
+   * @param entries - An array containing the column definitions for the table.
+   * @return The SQL statement as a string.
+   */
   createTable(tableName, entries) {
     return `CREATE TABLE IF NOT EXISTS ${tableName}  (
 	${entries.join(",\n	")}
 );`;
   }
+  /**
+   * Statement to rename a table.
+   *
+   * @param tableName - The name of the existing table to be renamed.
+   * @param newTableName - The new name for the table.
+   * @return The SQL statement as a string.
+   */
   renameTable(tableName, newTableName) {
     return `ALTER TABLE ${tableName} RENAME TO ${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 ${tableName};`;
   }
-  columnDefinition(columnName, type, defaultValue, isPrimaryKey) {
-    const query = `${columnName} ${type} DEFAULT ${defaultValue}`;
+  /**
+   * 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 = `${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 ${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 ${tableName} RENAME COLUMN ${oldColumnName} TO ${newColumnName};`;
   }
-  copyColumn(tableName, oldColumnName, newColumnName) {
-    return `UPDATE ${tableName} SET ${newColumnName} = ${oldColumnName};`;
-  }
+  /**
+   * 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 ${tableName} DROP COLUMN ${columnName};`;
   }
+  /**
+   * Statement to return data from a table.
+   *
+   * @param tableName - The name of the database table to select data from.
+   * @param select - An array of column names to include in the SELECT clause.
+   * @param where - An optional condition.
+   * @return The SQL statement as a string.
+   */
   select(tableName, select, where) {
     let query = `SELECT ${select.join(",")} FROM ${tableName}`;
     if (where)
       query += ` WHERE ${where}`;
     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 ${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}) ${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("version", this.typeInt, "0", false)
+      this.columnDefinition("version", this.types.number, false, "0")
     ]);
   }
+  /**
+   * Fetches the foreign keys for the specified table.
+   * This method is only used if {@link canInspectForeignKeys} is true
+   *
+   * @param tableName - The name of the table for which to retrieve foreign key information.
+   * @return {Promise<ForeignKeyInfo[]>} A promise that resolves to an array of {@link ForeignKeyInfo}.
+   */
   async getForeignKeys(tableName) {
     throw new Error("Inspecting foreign keys is not supported!");
   }
+  /**
+   * 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.runMultipleWriteStatements(this.migrationTableQuery());
   }
-  //TODO: untested
+  /**
+   * 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, ["version"]);
     const data = await this.db.runGetStatement(query);
     return data.length ? data[0].version : 0;
   }
-  //TODO: untested
+  /**
+   * Updates the migration version in the database. If the version entry does not exist, it inserts a new one;
+   * if it exists, it updates the version to the specified value.
+   *
+   * @param newVersion - The new migration version to set in the database.
+   * @return A promise that resolves when the operation is complete.
+   */
   async setVersion(newVersion) {
     const query = `${this.migrationTableQuery()};
 INSERT INTO ${MIGRATION_DATA_TABLE_NAME} (version) VALUES ${newVersion} WHERE NOT EXISTS (SELECT 1 FROM ${MIGRATION_DATA_TABLE_NAME})
@@ -861,8 +1284,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: "INTEGER",
+    time: "INTEGER",
+    dateTime: "INTEGER",
+    null: "NULL"
+  };
   canAlterForeignKeys = false;
   canAlterPrimaryKey = false;
   canInspectForeignKeys = true;
@@ -875,21 +1306,30 @@ var SqliteDialect = class extends DefaultSql {
   }
   async getColumnInformation(tableName) {
     const data = await this.db.runGetStatement(`PRAGMA table_info(${tableName})`);
-    return data.map((entry) => {
-      return {
+    const output = {};
+    for (const entry of data) {
+      output[entry["name"]] = {
         name: entry["name"],
         type: entry["type"],
         defaultValue: entry["dflt_value"],
         isPrimaryKey: entry["pk"] == "1"
       };
-    });
+    }
+    return output;
   }
-  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) {
@@ -900,8 +1340,8 @@ var SqliteDialect = class extends DefaultSql {
         fromColumn: entry["from"],
         toTable: entry["table"],
         toColumn: entry["to"],
-        on_update: entry["on_update"],
-        on_delete: entry["on_delete"]
+        onUpdate: entry["on_update"] ?? "NO ACTION",
+        onDelete: entry["on_delete"] ?? "NO ACTION"
       };
     });
   }
@@ -934,14 +1374,17 @@ var PostgresDialect = class extends DefaultSql {
   }
   async getColumnInformation(tableName) {
     const data = await this.db.runGetStatement(`SELECT column_name, data_type, column_default FROM information_schema.columns WHERE table_schema = 'public' AND table_name = '${tableName}';`);
-    return data.map((entry) => {
-      return {
+    const output = {};
+    for (const entry of data) {
+      output[entry["name"]] = {
         name: entry["column_name"],
         type: entry["data_type"],
+        maxLength: 0,
         defaultValue: entry["column_default"],
         isPrimaryKey: false
       };
-    });
+    }
+    return output;
   }
   addPrimaryKey(tableName, columnName) {
     return `ALTER TABLE ${tableName} ADD PRIMARY KEY (${columnName});
@@ -986,18 +1429,21 @@ var MsSqlDialect = class extends DefaultSql {
     });
   }
   async getTableNames() {
-    return await this.db.runGetStatement("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'");
+    return (await this.db.runGetStatement("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'")).map((entry) => entry.name);
   }
   async getColumnInformation(tableName) {
     const data = await this.db.runGetStatement(`SELECT COLUMN_NAME, DATA_TYPE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = N'${tableName};'`);
-    return data.map((entry) => {
-      return {
-        name: entry["COLUMN_NAME"],
+    const output = {};
+    for (const entry of data) {
+      output[entry["name"]] = {
+        name: entry["name"],
         type: entry["DATA_TYPE"],
+        maxLength: 0,
         defaultValue: entry["COLUMN_DEFAULT"],
-        isPrimaryKey: false
+        isPrimaryKey: entry["pk"] == "1"
       };
-    });
+    }
+    return output;
   }
 };
 
@@ -1007,9 +1453,26 @@ var MySqlDialect = class extends DefaultSql {
   canAlterPrimaryKey = true;
   canInspectForeignKeys = true;
   canInspectPrimaryKey = true;
+  types = {
+    string: "VARCHAR",
+    number: "INT",
+    bigint: "BIGINT",
+    boolean: "BOOLEAN",
+    date: "DATE",
+    time: "TIME",
+    dateTime: "DATETIME",
+    null: "NULL"
+  };
+  getSqlType(dataType, columnInfo) {
+    switch (dataType) {
+      case "string":
+        return this.types[dataType] + `(${columnInfo?.maxLength})`;
+      default:
+        return super.getSqlType(dataType, columnInfo);
+    }
+  }
   changeForeignKeysState(enabled) {
-    return `SET FOREIGN_KEY_CHECKS ${enabled ? "1" : "0"}
-;`;
+    return `SET FOREIGN_KEY_CHECKS ${enabled ? "1" : "0"};`;
   }
   addForeignKey(fromTableName, foreignKey) {
     return `ALTER TABLE ${fromTableName} ADD ${foreignKey};`;
@@ -1035,18 +1498,22 @@ var MySqlDialect = class extends DefaultSql {
     });
   }
   async getTableNames() {
-    return await this.db.runGetStatement("SHOW TABLES;");
+    const t = await this.db.runGetStatement("SELECT table_name FROM information_schema.tables;");
+    return (await this.db.runGetStatement("SELECT table_name FROM information_schema.tables;")).map((entry) => entry.name);
   }
   async getColumnInformation(tableName) {
     const data = await this.db.runGetStatement(`SHOW COLUMNS FROM ${tableName};`);
-    return data.map((entry) => {
-      return {
-        name: entry["Field"],
-        type: entry["Type"],
-        defaultValue: entry["Default"],
-        isPrimaryKey: entry["Key"] == "PRI"
+    const output = {};
+    for (const entry of data) {
+      output[entry["name"]] = {
+        name: entry["name"],
+        type: entry["type"],
+        maxLength: 0,
+        defaultValue: entry["dflt_value"],
+        isPrimaryKey: entry["pk"] == "1"
       };
-    });
+    }
+    return output;
   }
 };
 
@@ -1126,8 +1593,10 @@ async function rollback(db, dbInstructions, toVersion) {
   await dialect.setVersion(toVersion);
 }
 export {
-  DbTable,
+  DataType,
   ForeignKey,
+  TableClass,
+  TableObj,
   prepareAndRunMigration,
   prepareMigration,
   rollback,